[serialdev]

This really makes me excited, there is no reason why we cannot implement a thorough type-system like qi and shen on top of common-lisp for massive teams, the repl experience is still unparalleled, and I for one would love more libraries popping up, so maybe more people can make a business case for it. Machine learning in python is nice, but I would definitely enjoy common lisp for it too!

[lisper]

> there is no reason why we cannot implement a thorough type-system like qi

The SBCL compiler actually has a type inference engine built in to it.

[lispm]

Many CL implementations have a type inferencer (usually so that the compiler can optimize code without the developer having to specify types everywhere). What sets SBCL (and CMUCL and Scieneer CL) apart is that it does limited forms of compile time type checking:

http://www.sbcl.org/manual/index.html#Handling-of-Types

[lisper]

> type inferencer

> compile time type checking

Aren't those the same thing?

[lispm]

No. A type inference does not check types. It inferences types.

For example if you know that + is defined for numbers, then you can inference that a and b must be numbers: (+ a b)

If you know that a and b are numbers then you can inference that subexpressions need to deal with numbers only:

   (let ((a c) (b d)) (declare (type number a b)) ....)

The type inferencer then will tell what types the various expressions have. It will try to propagate known types as widely as possible in the code.

Allegro CL and LispWorks for example are doing this type inference. But their compiler will not tell you that type declarations are violated.

SBCL OTOH treats type declarations as type assertions which can be checked at compile time. ADDITIONALLY it also does type inference - and additionally uses this information for compile time type checks.

[lisper]

> A type inference does not check types. It inferences types.

OK, on that definition, of what possible use is a type inferencer? Aren't they useful only as a component of a compile-time type checker?

[lispm]

Convenience.

Basically CCL's compiled code is often as fast as code from SBCL, LispWorks, Allegro CL. But one has to declare much more types of variables and functions explicitly with CCL. The code needs to be littered with type declarations.

A compiler with a (better) type inferencer can propagate the type information it already has and this is often enough for fast code. A good compiler can then also tell the developer where it lacks type information and then you can decide to declare types explicitly. SBCL/CMUCL does that in a very noisy way with lots of information generated by the compiler. ;-)

See for example: http://home.pipeline.com/~hbaker1/TInference.html

[ken]

Performance. If you have (+ x y) and you can infer that x and y are fixints, then you can use a couple inline opcodes, rather than calling GENERIC-+.

EDIT: lispm is right, too, of course. You can look at it either way. If your program required top performance and you were going to tag every type until it ran super fast, then inference buys you the convenience of not needing to do as much. If you weren't going to bother with that, then inference buys you extra performance without all the effort.

[JasonFruit]

('Infer' is a perfectly good verb; you don't have to make one out of 'inference'. But sometimes it's easy to disremembrance things like that on HN.)

[lisper]

I believe lispm is not a native English speaker. His website TLD is .de.

[lispm]

Thanks, didn't remember that.

[eslaught]

> SBCL OTOH treats type declarations as type assertions which can be checked at compile time.

Wait, is that really not the standard behavior?

[lispm]

CMUCL invented that in the mid/end 80s. CMUCL forks like SBCL and Scieneer CL got it there. The other compilers don't do that.

[omaranto]

I don't think so. A type inferencer figures out types of expressions that don't have a type explicitly declared using information it has about other things that are declared.

A compile time type checker is expected to signal errors at compile time for programs whose types don't check out.

You can use a type inferencer without signaling any errors at compile time (for example, by deferring errors to runtime) and you can signal type errors at compile time even if you don't infer any types (like C compilers, that demand all variables have a declared type).

[rayiner]

(I feel sheepish even saying this to you), but when people say "type inferencing" I think these days they tend to mean "inference of static types that are enforced at compile time within a rich static type system." SBCL infers static types within a (mostly) dynamic, permissive type system. It can enforce certain constraints at compile time, but it’s ad hoc (there is no well-defined model of what properties it can prove at compile time on any valid code).

[lispm]

Type inferencing has a long tradition inside the Lisp community - for a language which is not statically typed, but which might be able to use type hints and static type information about the base language. Many Lisp compilers use type inference for optimization purposes.

[ken]

Is there an alternative term which has arisen for what Lisp traditionally calls "type inference"?

[rayiner]

SBCL calls it type propagation, which is fairly descriptive. (At least in SBCL, it's implemented as a data flow analysis that propagates constraints on the types of lexical variables: https://www.pvk.ca/Blog/2013/11/22/the-weaknesses-of-sbcls-t...).