type inference Concepts

Scala in Depth

by Tom Kleenex and Joshua Suereth · 2 Jan 2010 · 554pp · 108,035 words

functional concepts 1.1.2. Examining functional concepts in Google Collections 1.2. Static typing and expressiveness 1.2.1. Changing sides 1.2.2. Type inference 1.2.3. Dropping verbose syntax 1.2.4. Implicits are an old concept 1.2.5. Using Scala’s implicit keyword 1.3. Transparently

…

reduce boilerplate in code and keep things concise. Scala made a few simple design decisions that help make it expressive: Changing sides of type annotation Type inference Scalable syntax User-defined implicits Let’s look at how Scala changes the sides of type annotations. 1.2.1. Changing sides Scala places type

…

concerns of how a variable behaves from the variable type, the placement of types on the right allows type inference to determine the type of the variables. 1.2.2. Type inference Scala performs type inference wherever possible. Type inference is when the compiler determines what the type annotation should be, rather than forcing the user to specify

…

well. Scala made choices about syntax that drastically reduced the verbosity of the language and enabled some powerful features to be elegantly expressed, such as type inference. Finally, Scala has tight integration with Java and runs on top of the Java virtual machine, which is perhaps the single most important aspect to

…

more advanced features, starting with its object orientation. Chapter 4. Utilizing object orientation In this chapter Object initialization Abstract methods Composition and Inheritance Abstract interfaces Type inference and public APIs Scala is a rich object-oriented language. In Scala, every value is an object. Even operators are method calls against the class

…

implementation details, it’s best to provide explicit return types on public methods in your API. This can also help speed compilation slightly, as the type inferences don’t need to figure out a return type, and it gives a chance for your implicit conversions to kick in, coercing things to the

…

new values to be mixed in via inheritance. This technique provides the most flexibility when pure abstract interfaces are used for the API systems. Finally, type inference can change an API as the object model expands. For public methods, it’s best to explicitly annotate return types on critical interfaces. This leads

…

will attempt to infer a type parameter that matches all the arguments. Scala’s List.apply is a parameterized method. Let’s look at this type inference in action. scala> List(1.0, "String") res7: List[Any] = List(1.0, String) scala> List("String", Seq(1)) res8: List[java.lang.Object] = List

…

In Scala, the choice of making something variant or not is important. The variance annotation can affect a lot of the mechanics in Scala, including type inference. The safest bet when working with variance is to start with everything invariant and mark variance as needed. In general, when running into covariance or

…

is known by the compiler; instead these can be captured with another implicit at compile time. 7.2.3. Capturing type constraints The intersection of type inference and type constraints sometimes causes issues where you need to use reified type constraints. What are reified type constraints? These are objects whose implicit existence

…

until later in the algorithm. Scala’s type inferencer works in a left-to-right fashion across parameter lists. This allows the types inferred from one parameter list to affect the types inferred in the next parameter list. A great example of this left-to-right inference is with anonymous functions using collections. Let

…

to find both types C and A using only one parameter. To solve this, let’s make a new implementation of peek that defers some type inference for the second parameter list: scala> def peek[C, A](col: C)(implicit ev: C <:< Traversable[A]) = | (col.head, col) foo: [C,A](col: C

…

is the type returned if the natural number is _0. The third type is an upper bound for the first two types to avoid compilation type inference issues. Let’s implement this type on the _0 and Succ traits: sealed trait _0 extends Nat { type Expand[NonZero[N <: Nat] <: Ret, IfZero <: Ret

…

carry the most specific type through a generic method so that it can be used in the return value. Deferring Type Inference of Parent-Class Type Parameters The need to defer the type inference for a type parameter Foo <: Seq[T] is necessary for supporting the Scala 2.8.x series. As of the

…

Scala 2.9.x, the type inference algorithm was improved such that the implicit <:< parameter is no longer necessary. The next type parameter in the sort method is the cbf : CanBuildFrom[Coll,

…

that <: LinearSeqLike[T,Coll], the with keyword must also be used to explicitly join the Coll type with LinearSeqLike[T,Coll]. Once this is completed, type inference will work correctly for Coll. This implementation of sort is generic but may be suboptimal for different types of collections. It would be ideal if

…

the A and B types from the naiveWrap method. The solution to this problem is one used from 7.2.3: We can defer the type inference of the parameters. Let’s try to implement the wrap method again. trait CollectionConverter[A] { val col: java.util.Collection[A] def asScala[B](implicit

…

method specialization specialized methods split method Splitable Static class static fields, and annotations static methods static typing dropping verbose syntax implicits type annotations for variables type inference statics Stream class, 2nd, 3rd stream collections, 2nd Stream.empty strictEquals method String class, 2nd, 3rd, 4th, 5th, 6th, 7th String object structural types, 2nd

…

two-dimensional geometric point class two-dimensional plane type annotations, for variables type classes benefits of FileLike as type constraints, 2nd, 3rd type erasure, 2nd type inference type keyword type lambda type system, conditional execution using heterogeneous typed list IndexedView type type traits U useFile method UserService class UserServiceImpl class UserSession object

Programming Scala

by Unknown · 2 Jan 2010 · 448pp · 71,301 words

much smaller. Many developers who find static languages too verbose often blame static typing for the verbosity when the real problem is a lack of type inference. In type inference, the compiler infers the types of values based on the context. For example, the compiler will recognize that x = 1 + 3 means that x

…

must be an integer. Type inference reduces verbosity significantly, making the code feel more like code written in a dynamic language. We have worked with both static and dynamic languages, at

…

can be verbose. Scala uses a number of techniques to minimize unnecessary syntax, making Scala code as succinct as code in most dynamically typed languages. Type inference minimizes the need for explicit type information in many contexts. Declarations of types and functions are very concise. Scala allows function names to include non

…

typing constructs. The type system can be intimidating at first, but most of the time you won’t need to worry about the advanced constructs. Type inference helps by automatically inferring type signatures, so that the user doesn’t have to provide trivial type information manually. When you need them, though, the

…

practical needs for enterprise and Internet projects. Scala is compelling because it feels like a dynamically typed scripting language, due to its succinct syntax and type inference. Yet Scala gives you all the benefits of static typing, a modern object model, functional programming, and an advanced type system. These tools let you

…

have to specify the type parameters <Integer, String> twice. (Scala uses the term type annotations for explicit type declarations like HashMap<Integer, String>.) Scala supports type inference (see, for example, [TypeInference] and [Pierce2002]). The language’s compiler can discern quite a bit of type information from the context, without explicit type annotations

…

on the lefthand side because all of the type information needed is on the righthand side. The compiler automatically makes intToStringMap2 a HashMap[Integer,String]. Type inference is used for methods, too. In most cases, the return type of the method can be inferred, so the : and return type can be omitted

…

. However, type annotations are required for all method parameters. Pure functional languages like Haskell (see, e.g., [O’Sullivan2009]) use type inference algorithms like Hindley-Milner (see [Spiewak2008] for an easily digested explanation). Code written in these languages require type annotations less often than in Scala, because

…

Scala’s type inference algorithm has to support object-oriented typing as well as functional typing. So, Scala requires more type annotations than languages like Haskell. Here is a

…

.io.File = ~/.myapprc scala> val configFilePath = if (configFile.exists()) { | configFile.getAbsolutePath() | } configFilePath: Unit = () scala> Note that configFilePath is now Unit. (It was String before.) The type inference picks a type that works for all outcomes of the if expression. Unit is the only possibility, since no value is one possible outcome. Scala

…

first time. However, the type system can be intimidating at first, especially if you come from a dynamically typed language like Ruby or Python. Fortunately, type inference hides most of the complexities away. Most of the time, you don’t need to know the particulars, so we encourage you not to worry

…

necessary for users of Scala parameterized types, who don’t need to specify this behavior when using parameterized types. (Scala users also benefit greatly from type inference.) Let’s look at a Java example, a simplified Java version of Scala’s Option, Some, and None types: // code-examples/TypeSystem/variances/Option.java

…

existential type syntax very often in Scala code, because existential types exist primarily to support Java generics while preserving correctness in Scala’s type system. Type inference hides the details from us in most contexts. When working with Scala types, the other type constructs we have discussed in this chapter are preferred

…

code size when using Scala. [SMRa] attributes this code reduction to Scala’s support for higher-order and anonymous functions, its sophisticated type system and type inference, and the ability of for comprehensions to generate maps in an elegant and succinct way. Recap and What’s Next This chapter filled in the

…

-language-and-scalable.html. [SMRb] Scala Map Reduce, http://github.com/dlwh/smr/. [Smith2009a] Eishay Smith, Beware of Scala’s Type Inference, http://www.eishay.com/ 2009/05/beware-of-scalas-type-inference.html. [Smith2009b] Eishay Smith, Unexpected repeated execution in Scala, http://www.eishay .com/2009/06/unexpected-repeated-execution-in-scala.html

…

, http://testng.org/. [Turbak2008] Franklyn Turbak, David Gifford, and Mark A. Sheldon, Design Concepts of Programming Languages, The MIT Press, 2008. [TypeInference] Type inference, http://en.wikipedia.org/wiki/Type_inference. [VanRoy2004] Peter Van Roy and Seif Haridi, Concepts, Techniques, and Models of Computer Programming, The MIT Press, 2004. [Wampler2008] Dean Wampler, Traits vs

…

An explicit declaration of the type of a value, e.g., count: Int, where Int is the type annotation. A type annotation is required when type inference can’t be used. In Scala, function parameters require type annotations, and annotations are required in some other contexts where the type can’t be

…

model. So, for example, instances of 404 | Glossary Download at WoweBook.Com Visibility List[String] and List[Int] are indistin- guishable. Contrast with reified types. Type Inference Inferring the type of a value based on the context in which it is used, rather than relying on explicit type annotations. Sometimes called implicit

…

type declarations, 268 views and view bounds, 263 type constructors, 404 type designators, 275, 404 type erasure, 90 defined, 405 getClass method on JVM, 248 type inference, 29–36, 405 type projections, 279, 405 type system, 2, 247 (see also data types) Scala, 6 type variance, 251, 405 (see also variance under

Real World Haskell

by Bryan O'Sullivan, John Goerzen, Donald Stewart and Donald Bruce Stewart · 2 Dec 2008 · 1,065pp · 229,099 words

around types. A major reason for the popularity of dynamically typed languages is that only rarely do we need to explicitly mention types. Through automatic type inference, Haskell offers the same advantage. Beyond this surface similarity, the differences run deep. In a dynamically typed language, we can create constructs that are difficult

…

pieces are 1×1 squares and always fit, so you have to constantly examine the resulting picture and check (through testing) whether it’s correct. Type Inference Finally, a Haskell compiler can automatically deduce the types of almost[3] all expressions in a program. This process is known as

…

type inference. Haskell allows us to explicitly declare the type of any value, but the presence of type inference means that this is almost always optional, not something we are required to do. What to Expect

…

make sure that your program passes the scrutiny of the type checker. Why stick with the learning curve? While strong, static typing makes Haskell safe, type inference makes it concise. The result is potent: we end up with a language that’s safer than popular statically typed languages and often more expressive

…

to render JSON data to a string, and then compress to another string, postponing any decision on how to actually display or transmit the data. Type Inference Is a Double-Edged Sword A Haskell compiler’s ability to infer types is powerful and valuable. Early on, you’ll probably face a strong

…

temptation to take advantage of type inference by omitting as many type declarations as possible. Let’s simply make the compiler figure the whole lot out! Skimping on explicit type information has

…

piece of code for quite a while, until enlightenment strikes. Every time we write a type signature, we remove a degree of freedom from the type inference engine. This reduces the likelihood of divergence between our understanding of our code and the compiler’s. Type declarations also act as shorthand for us

…

which document variant to generate, and then dispatch based on the result. To generate concat or union document nodes, we just recurse on arbitrary, letting type inference determine which instance of Arbitrary we mean: -- file: ch11/QC.hs instance Arbitrary Doc where arbitrary = do n <- choose (1,6) :: Gen Int case n

…

list of strings. The st can be ignored for now. Parsec programmers often omit type declarations, since we write so many small functions. Haskell’s type inference can figure it out. We’ve listed the types for the first example, here so you can get a better idea of what’s going

…

brevity, we have given the type for only the first one, but all three have the same type, and Haskell can work them out via type inference. Notice our implementation of guiFetch. We don’t call statusWindow twice, but rather combine functions in its action. The final piece of the puzzle consists

…

bang patterns, we can hint at strictness on any binding form, making the function strict in that variable. Much as explicit type annotations can guide type inference, bang patterns can help guide strictness inference. Bang patterns are a language extension and are enabled with the BangPatterns language pragma. We can now rewrite

…

, Handling Errors Through API Design errors, Boolean Logic, Operators, and Value Comparisons, Boolean Logic, Operators, and Value Comparisons, Strong Types, Algebraic Data Types, Reporting Errors, Type Inference Is a Double-Edged Sword, More Helpful Errors, Standard Input, Output, and Error, Handling Errors Through API Design, Reporting Parse Errors, Error Handling, Error Handling

…

Data Types–Exceptions, Custom data types for errors, Error Handling in Monads, Error Handling API design, handling, Handling Errors Through API Design compiling source code, Type Inference Is a Double-Edged Sword custom data types for, Custom data types for errors handling, Error Handling–Exceptions, Error Handling with Data Types–Exceptions, Error

…

type constructors, Defining a New Data Type, Looking for Shared Patterns, Almost a State Monad Monads and, Looking for Shared Patterns, Almost a State Monad type inference, Type Inference, Type Inference Is a Double-Edged Sword–A More General Look at Rendering type keyword, Type Synonyms type signatures, Some Common Basic Types type variables, Useful Composite

Haskell Programming: From First Principles

by Christopher Allen and Julie Moronuki · 1 Jan 2015 · 1,076pp · 67,364 words

107 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108 109 109 111 116 123 125 126 130 131 Types . . . . . . . . . . . . . . . . . . . . What are types? . . . . . . . . . . . . . . Querying and Reading Types . . . . Typeclass constrained type variables Currying . . . . . . . . . . . . . . . . . . Polymorphism . . . . . . . . . . . . . . Type inference . . . . . . . . . . . . . . Asserting types for declarations . . . Chapter Exercises . . . . . . . . . . . . Deﬁnitions . . . . . . . . . . . . . . . . . Follow-up resources . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135 136 136 139 141 144 153 158 161 163 171 173 4 Basic datatypes

…

is more pleasant and less repetitious. Also note we explicitly declared the type of woot in the where clause. This wasn’t necessary (Haskell’s type inference would’ve ﬁgured it out ﬁne), but it was done here to show you how in case you need to. Be sure to load and

…

and reading type signatures; • see that currying has, unfortunately, nothing to do with food; • take a closer look at diﬀerent kinds of polymorphism; • look at type inference and how to declare types for our functions. 5.2 What are types? Expressions, when evaluated, reduce to values. Every value has a type. Types

…

that you’re passing the right sort of data around, which can help tremendously. Haskell’s type system allows for a nifty feature known as type inference. We can declare our types when we write our programs, but the compiler will infer the types for expressions that have no declared type. It

…

is better to have explicit type declarations in any nontrivial CHAPTER 5. TYPES 139 program, but type inference can be helpful as you’re learning and experimenting with writing new programs. An example of a type is Bool, which we remember from the

…

does not obligate us to assert a type for every expression or value in our programs because it has type inference. Type inference is an algorithm for determining the types of expressions. Haskell’s type inference is built on an extended version of the Damas-HindleyMilner type system. Haskell will infer the most generally applicable (polymorphic

…

good practice to explicitly declare them. Remember when we suggested that a good type system was like a pleasant conversation with a colleague? Think of type inference as a helpful colleague working through a problem with you. For example, we can write id ourselves. Prelude> let ourId x = x CHAPTER 5. TYPES

…

no information by which to infer the types for any of those variables (other than that they are lists of some sort). Let’s see type inference at work. Open your editor of choice and enter the following snippet: -- typeInference1.hs module TypeInference1 where f :: Num a => a -> a -> a f x

…

-> Bool myAlph x = x < 'z' 5.8 Asserting types for declarations Most of the time, we want to declare our types, rather than relying on type inference. Adding type signatures to your code can provide guidance to you as you write your functions. It can also help the compiler give you information

…

. It’s worth remembering that GHC will pick up and propagate type information for inference from applications of functions, sub-expressions, deﬁnitions — almost anywhere. The type inference is strong with this one. There are constraints on our ability to declare types. For example, if we try to make the (+) function return a

…

f :: f -> g -> C Write a type signature For the following expressions, please add a type signature. You should be able to rely on GHCi type inference to check your work, although you might not have precisely the same answer as GHCi gives (due to polymorphism, etc). 1. While we haven’t

…

, Blah) g = ??? Here it’s 𝑔 that you’re supposed to implement; however, you can’t evaluate anything. You’re to only use type-checking and type-inference 3 https://twitter.com/SixBitProxyWax CHAPTER 5. TYPES 169 to validate your answers. Also note that we’re using a trick for deﬁning datatypes which

…

here is the -- parametrically polymorphic 'a'. -- Given these types (Ord a, Num a) => a Integer -- The principal type is -- (Ord a, Num a) => a 3. Type inference is a faculty some programming languages, most notably Haskell and ML, have to infer principal types from terms without needing explicit type annotations. There are

…

type can’t be an Int). Ordinarily the concrete type would come from the type signature CHAPTER 6. TYPECLASSES 183 you’ve speciﬁed or from type inference, such as when a Num a => a is used in an expression that expects an Integer which forces the polymorphic number value to concretize as

…

the instance of Numberish for Age because it could see that our arguments to sumNumberish were of type Age. We can see this with the type inference, too: Prelude> :t sumNumberish sumNumberish :: Numberish a => a -> a -> a Prelude> :t sumNumberish (Age 10) sumNumberish (Age 10) :: Age -> Age After the ﬁrst parameter is

…

, and t2 which could be diﬀerent types. They are allowed but not required to be diﬀerent types. They’re all polymorphic because we gave the type inference nothing to go on with respect to what type they could be. The type variables are diﬀerent because nothing in our code is preventing them

…

what’s data? As we’ve said, types are static and resolve at compile time. Types are known before runtime, whether through explicit declaration or type inference, and that’s what makes them static types. Information about types does not persist through to runtime. Data are what we’re working with at

…

we use our List type? -- from GHCi Prelude> let nil = Nil -- the type parameter isn't applied because -- Nil by itself doesn't tell the type inference -- what the List contains. Prelude> :t nil nil :: List a Prelude> let oneItem = (Cons "woohoo!" Nil) Prelude> :t oneItem oneItem :: List [Char] And how are

…

‘v’ Expected a type, but ‘v’ has kind ‘k0 -> *’ In the type ‘v a -> v’ In the class declaration for ‘AlsoImp’ Just as GHC has type inference, it also has kind inference. And just as it does with types, it can not only infer the kinds but also validate that they’re

Scala in Action

by Nilanjan Raychaudhuri · 27 Mar 2012

following features: Higher-order functions (chapter 4) Lexical closures (chapter 3) Pattern matching (chapters 2 and 3) Single assignment (chapter 2) Lazy evaluation (chapter 2) Type inference (chapter 2) Tail call optimization (chapter 5) List comprehensions (chapters 2 and 4) Mondadic effects (chapter 5) Side effects A function or expression is said

…

a dynamically typed language, but with all the benefits of a statically typed language. Definition Type inference is a technique by which the compiler determines the type of a variable or function without the help of a programmer. The compiler can deduce

…

variable s in s="Hello" will have the type string because "hello" is a string. The type inference ensures the absence of any runtime type errors without putting a declaration burden on the programmer. To demonstrate how type inference works, create an array of maps in Scala: val computers = Array( Map("name" -> "Macbook", "color

…

with the power of abstractions from both functional and OOP models. Functional programming and actors will make your concurrent programming easy and maintainable. Scala’s type inference takes care of the pain of boilerplate code so that you can focus on solving problems. In the next chapter you’ll set up your

…

a decimal number. You can specify the type of variable (sometimes called only value; more on this later) that you want when you think Scala type inference isn’t producing the result you are seeking. If you declare a variable with an integer literal, for example, Scala creates a variable of type

…

.lang.String; it’s Unit. Unit in Scala is like void in Java, and it means that the method doesn’t return anything. Tip Scala type inference is powerful, but use it carefully. If you’re creating a library and plan to expose your functions as a public API, it’s a

…

; otherwise b is returned. Even though the return type is optional, you do have to specify the type of the parameters when defining functions. Scala type inference will figure out the type of parameters when you invoke the function but not during the function declaration.[4],[5] 4

…

, http://mng.bz/32jw. 5 Daniel Spiewak, posted at Code Commit, “What is Hindley-Milner? (and why is it cool?),” undated, http://mng.bz/H4ip. Type inference If you have a background in Haskell, OCaml, or any other type of inferred programming language, the way Scala parameters are defined could feel a

…

bit weird. The reason is that Scala doesn’t use the Hindley-Milner algorithm to infer type; instead Scala’s type inference is based on declaration-local information, also known as local type inference. Type inference is out of the scope of this book, but if you’re interested you can read about the Hindley-Milner

…

type inference algorithm and why it’s useful. Sometimes it becomes necessary to create a function that will take an input and create a List from it.

…

) => a + b is called an anonymous function, or a function without a predefined name. You can improve your function by taking advantage of Scala’s type inference: scala> evenNumbers.foldLeft(0) { (a, b) => a + b } res20: Int = 30 Usually you have to specify the type of the parameter for top-level functions

…

(filename.endsWith(".scala")) System.out.println(file); } In the case of Scala, you don’t have to specify the type of file object because Scala type inference will take care of it. Apart from the generator, you can use other ingredients in a Scala for loop to simplify the previous example. for

…

same name), you have to specify the return type; otherwise, the code won’t compile. You have a similar limitation for recursive method calls. Scala type inference can’t infer the type of recursive methods or functions. In case of type errors, it’s always helpful to add type information. Using the

…

) res11: Int = -1 Even though you can explicitly specify the type value for the type parameter as in the last example, it’s optional. Scala type inference determines the value of the type parameter based on the arguments passed to the function. Currently your position function returns -1 when there’s no

Programming in Scala

by Martin Odersky, Lex Spoon and Bill Venners · 15 Jan 2008 · 754pp · 48,930 words

-order methods on class List . . . . . . . . 16.7 Higher-order methods on class List . . . . . . 16.8 Methods of the List object . . . . . . . . . . . 16.9 Understanding Scala’s type inference algorithm . 16.10 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 327 327 328 328 329 330 332 343 351 355 358 17 Collections 17.1 Overview of the library . . . . . . . . . . . . . . . . . 359 359

…

Java version.9 The Scala class is quicker to write, easier to read, and most importantly, less error prone than the Java class. Scala’s type inference is another factor that contributes to its conciseness. Repetitive type information can be left out, so programs become less cluttered and more readable. But probably

…

system is far from being a “complete pain.” In fact, it addresses nicely two of the usual concerns about static typing: verbosity is avoided through type inference and flexibility is gained through pattern matching and several new ways to write and compose types. With these impediments out of the way, the classical

…

a HashMap with Ints as keys and Strings as values; there’s no need to repeat the same phrase twice. Scala has a very sophisticated type inference system that lets you omit almost all type information that’s usually considered annoying. In the previous example, the following two less annoying alternatives would

…

work just as well: val x = new HashMap[Int, String]() val x: Map[Int, String] = new HashMap() Type inference in Scala can go quite far. In fact, it’s not uncommon for user code to have no explicit types at all. Therefore, Scala programs

…

“Type variable” in Java. Scala’s postfix type syntax resembles Pascal, Modula-2, or Eiffel. The main reason for this deviation has to do with type inference, which often lets you omit the type of a variable or the return type of a method. Using the “variable: Type” syntax this is easy

…

to start the definition anymore. You’d need some alternative keyword to be a placeholder for a missing type (C# 3.0, which does some type inference, uses var for this purpose). Such an alternative keyword feels more ad-hoc and less regular than Scala’s approach. 16 Landin, “The Next 700

…

variables in Java, you’ll notice one striking difference here: neither java.lang.String nor String appear anywhere in the val definition. This example illustrates type inference, Scala’s ability to figure out types you leave off. In this case, because you initialized msg with a string literal, Scala inferred the type

…

the next section, you’ll see better approaches that avoid iterating through arrays with indexes. This script starts with a variable definition, var i = 0. Type inference gives i the type scala.Int, because that is the type of its initial value, 0. The while construct on the next line causes the

…

more explicit mood, you could have specified the type of greetStrings explicitly like this: val greetStrings: Array[String] = new Array[String](3) Given Scala’s type inference, this line of code is semantically equivalent to the actual first line of Listing 3.1. But this form demonstrates that while the type parameterization

…

"), List(3, 2)) (_.length != _) res63: Boolean = false The fast track In the next (and final) section of this chapter, we provide insight into Scala’s type inference algorithm. You can safely skip the entire section if you’re not interested in such details right now, and instead go straight to the conclusion

…

on page 358. Cover · Overview · Contents · Discuss · Suggest · Glossary · Index 354 Section 16.9 Chapter 16 · Working with Lists 16.9 Understanding Scala’s type inference algorithm One difference between the previous uses of sort and msort concerns the admissible syntactic forms of the comparison function. Compare: scala> msort((x: Char

…

function ((x$1, x$2) => x$1.$greater(x$2)) msort(_ > _)(abcde) ˆ To understand why, you need to know some details of Scala’s type inference algorithm. Type inference in Scala is flow based. In a method application m(args), the inferencer first checks whether the method m has a known type. If it

…

its parameters are swapped: def msortSwapped[T](xs: List[T])(less: (T, T) => Boolean): List[T] = { // same implementation as msort, // but with arguments swapped } Now type inference would succeed: scala> msortSwapped(abcde)(_ > _) res67: List[Char] = List(e, d, c, b, a) What has happened is that the inferencer used the known type

…

result of type B, i.e., op: (A, B) => B. Because the type of z is not related to the type of the list xs, type inference has no context information for z. Now consider the erroneous expression in the method flattenRight above: (xss :\ List()) (_ ::: _) // this won’t compile The start value

…

! It says that the operation always takes an empty list as second argument and always produces an empty list as result. In other words, the type inference settled too early on a type for List(), it should have waited until it had seen the type of the operation op. So the (otherwise

…

programmer. This example highlights some limitations of the local, flow-based type inference scheme of Scala. It is not present in the more global HindleyMilner style of type inference used in functional languages such as ML or Haskell. However, Scala’s local type inference deals much more gracefully with object-oriented subtyping than the Hindley-Milner

…

, the higher-order operations like map, and the utility methods in the List object. Along the way, you learned a bit about how Scala’s type inference works. Lists are a real work horse in Scala, so you will benefit from knowing how to use them. For that reason, this chapter has

…

tail recursive if the only place the function calls itself is the last operation of the function. target typing Target typing is a form of type inference that takes into account the type that’s expected. In nums.filter((x) => x > 0), for example, the Scala compiler infers type of x to

…

, 527 Pizza language, xxvii, 57 placeholder syntax in existentials, 603 in function literals, 180, 197 PLT-Scheme language, 57 pointers, see references polymorphism, 222 and type inference, 357 pop method on class Stack, 366 Popescu, Alexandru, 285 postconditions, see ensuring method postfix operator notation, 118 pre-initialized fields, 441 precedence, operator, 124

…

a class instead, 385 type aliases, 436 type annotations, 40, 54, 60 for debugging, 358 type casts, see casting type constructors, 417 type erasure, 306 type inference, 55, 85n Hindley-Milner style, 358 the algorithm, 355 type keyword in singleton types, such as db.type, 567 Cover · Overview · Contents · Discuss · Suggest · Glossary

Programming Scala: tackle multicore complexity on the JVM

by Venkat Subramaniam · 1 May 2009 · 226pp · 17,533 words

. . . . . . . . . . . . . . . . . . Download at Boykma.Com CONTENTS 5 6 7 8 9 Sensible Typing 5.1 Collections and Type Inference . . . . 5.2 The Any Type . . . . . . . . . . . . . . 5.3 More About Nothing . . . . . . . . . . . 5.4 Option Type . . . . . . . . . . . . . . . 5.5 Method Return Type Inference . . . . 5.6 Passing Variable Arguments (Varargs) 5.7 Variance of Parameterized Type . . . . . . . . . . . . . . . . . . 63 64 66 67

…

need concurrency or conciseness (like creating domain-specific languages). Scala is a statically typed language, but, unlike Java, it has sensible static typing. Scala applies type inference in places it can. So, instead of specifying the type repeatedly and redundantly, you can rely on the language to learn the type and enforce

…

error with the following message: error: type mismatch; : java.lang.String("haha" ) found required: Int i = "haha" Later in this book you will see how type inference works beyond such simple definitions and transcends further to function parameters and return values. You can also run it as a script. See “Polyglot Programming

…

. If you attempt to assign some other type of value or instance to any of these variables, you’ll get a compilation error. Scala’s type inference is low ceremony1 and has no learning curve; you simply have to undo some Java practices. Scala’s static typing helps you in two ways

…

format. In this chapter, you’ll learn about Scala’s sensible static typing and type inference. You’ll also look at three special types in Scala: Any, Nothing, and Option. 5.1 Collections and Type Inference Scala will provide type inference and type safety for the Java Generics collections as well. The following is an example

…

that uses an ArrayList. The first declaration uses explicit, but redundant, typing. The second declaration takes advantage of type inference. As an aside, note that the underscore in the import statement is equivalent to the asterisks in Java. So when we type java.util._, we

…

safety in Scala. You don’t have to specify the type in order to benefit from Scala type checking. You can just rely on the type inference where it makes sense. The inference happens at compile time. So, you can be certain that the type checking takes effect right then when you

…

About Nothing You can see why you’d need Any, but what is the purpose of Nothing? Scala’s type inference works hard to determine the type of expressions and functions. If the type inferred is too broad, it will not help type verification. At the same time, how do you infer the type

…

for it to be compatible. However, an exception may occur at any place, so not all those expressions can be inferred as Int. Scala helps type inference work smoothly with the type Nothing, which is a subtype of all types. Since it is a subtype of all types, it is substitutable for

…

anything. Nothing is abstract, so you would not have a real instance of it anywhere at runtime. It is purely a helper for type inference purposes. Let’s explore this further with an example. Let’s take a look at a method that throws an exception and see how Scala

…

getOrElse( ) method on the returned Option[T], you can proactively indicate what to do in case the result is nonexistent (None). 5.5 Method Return Type Inference In addition to inferring the types of variables, Scala also tries to infer the return type of methods. However, there is a catch. It depends

…

the {}, as in the previous method3( ). This can be useful for simple getters and setters that perform minimal checks. You can also override the default type inference of Scala by providing the desired type, as in method4( ). We have declared the return type of method4( ) as Double. We may also declare it

…

to use the = and let Scala infer the type of methods. You have one less thing to worry about, and you can let the wellbuilt type inference do the job for you. 5.6 Passing Variable Arguments (Varargs) If your method takes parameters, you need to specify the parameter names and their

…

check for type soundness of variance annotation. In this chapter, we discussed the static typing in Scala and its type inference. You saw how this makes the code concise. With the understanding of typing, type inference, and how to write methods, you’re all set to learn and enjoy concepts that lead to more

…

binding in traits, 97–99 name conventions, 111–113 operators as, 43 overloading, 43–45 precedence, 44 public by default, 42, 48 changing, 48 return type inference, 69–70 static, 61–62 synchronized, 132 variable number of arguments (varargs), passing, 70–71 see also function values; functions mixing in traits, see traits

…

start() method, 141 static fields and methods, 61–62 static typing, 13, 18, 63–74 Any class, 46, 65–67 Nothing class, 65, 67–68 type inference, 64–66 method return type, 69–70 variable arguments (varargs), 70–71 variance of parameterized type, 71–74 stock ticker application (example), 187–210 building

…

binding in, 97–99 selective mixins, 94–95 transactions, ending deterministically, 85 try statements, 183 tuples, 38–40 matching against type, 119 pattern matching, 118 type inference, 64–66 method return type, 69–70 types function values, 82 implicit type conversions, 99–102 matching against, 119 typing, see static typing U unary

Essential TypeScript 4: From Beginner to Pro

by Adam Freeman

initialized. The code in Listing 11-13 produces the following output:Person: Bob Smith, London Person: Fidel Vega, Paris Fidel Vega works in Sales Understanding Type Inference for Subclasses Caution is required when letting the compiler infer types from classes because it is easy to produce unexpected results by assuming the compiler

…

.population}`)); export let empData = peopleData.collate(employees, "name", "name"); empData.forEach(c => console.log(`${c.name}, ${c.city}, ${c.role}`)); Listing 12-13.Using Generic Type Inference in the index.ts File in the src Folder The compiler is able to infer the type arguments based on the argument passed to the

…

Product("Kayak", 275), new Product("Lifejacket", 48.95)]; let names: string[] = processArray(products, selectName); names.forEach(name => console.log(`Name: ${name}`)); Listing 13-31.Using Type Inference for a Function in the index.ts File in the src Folder The Result<T> conditional type uses the infer keyword to obtain the result

…

type for a function that accepts an object of type T and produces an any result. The use of type inference allows functions that process a specific type to be used while ensuring that the result of the processArray function is a specific type, based on

…

as string, allowing the processArray function to return a string[] result. The code in Listing 13-31 produces the following output:Name: Kayak Name: Lifejacket Type inference in conditional types can be difficult to figure out, and TypeScript provides a series of built-in conditional types that are useful for dealing with

…

execution configuration configuration file declaration files errors library files setting modules format resolution supported formats polyfilling running the compiler tsconfig.json type inference watch mode Conditional types Constructor functions D Debugging break points debugger keyword remote debugging source maps using Node.js using Visual Studio Code Declaration files

…

indexed access operator index type queries index types interfaces iterables iterators method parameters type arguments type guards type inference type mappings type parameters constraining methods multiple parameters Git, installing I Index access operator Index signatures Index types Inferred types Interfaces abstract interfaces extending multiple interfaces optional methods optional properties Intersections correlation merging methods properties

…

Tuples optional elements using using as a type Type aliases Type annotations Type definitions Type predicate functions Types aliases conditional types generic types guards index types inference intersections literal values shape types type mappings Type unions asserting outside the union defining using U Unit testing configuration creating unit tests installing the test

Software Design for Flexibility

by Chris Hanson and Gerald Sussman · 17 Feb 2021

to elaborate, adventure game. In chapter 4 we introduce symbolic pattern matching, first to enable term-rewriting systems, and later, with unification, to show how type inference can easily be made to work. Here we encounter the need for backtracking because of segment variables. Unification is the first place where we see

…

to obtain more complete answers. This is most powerful when the contributions come from independent sources of information. In chapter 4 we will see how type inference is really a matter of combining multiple sources of partial information. Locally deducible clues about the type of a value, for example that a numerical

…

also add support for new kinds of syntactic variables, such as segment variables. But before we do that we will look at a real application: type inference. Exercise 4.10: Unifying vectors This unifier can be extended to handle data and patterns that are made of other data types, such as vectors

…

a good idea to do so? If not, why not? If so, do it! (This is hard!) 4.4.2 Application: Type inference One classic application of unification matching is type inference: given a program and some type information about parts of the program, deduce type information about other parts of the program. For

…

(type:procedure ((numeric-type) (numeric-type)) (numeric-type))) (iter 1 1))) (declare-type fact (type:procedure ((numeric-type)) (numeric-type)))) Here we see that the type inference program was able to determine the complete type of the factorial program—that it is a procedure that takes one numerical input and produces a

…

declaration has been posted: (declare-type n (numeric-type)) (declare-type product (numeric-type)) (declare-type counter (numeric-type)) 4.4.3 How type inference works The process of type inference has four phases. 1. The given program is annotated with type variables for all subexpressions of the program. 2. Constraints on the type

…

is then used by infer-program-types (on page 196) to instantiate the typed program. Critique Although this small type-inference system is a nice demonstration of unification, it is not very good at type inference: it doesn't really handle procedures very well. For example, consider the simple case: (pp (infer-program-types

…

for this problem, and make it as general as you can. Exercise 4.15: Parametric types This exercise examines what it takes to extend this type-inference system to work with parametric types. For example, the Scheme map procedure operates on lists of objects of any type. a. What must be done

…

not, explain why it is not necessary. b. Implement the changes required to allow parametric types to be used. Exercise 4.16: Union types The type-inference system we have outlined here does not have any support for union types. For example, the addition operator + is defined for numeric arithmetic. But what

…

not necessary. b. Implement the changes required to allow union types to be used. Note: This is not easy. Exercise 4.17: Side effects The type-inference system we have outlined here is adequate for pure functional programs. Can it be elegantly extended to work for programs with assignment? If you think

…

easy. It may be a nice term project to understand this and make it work. Exercise 4.18: Is this practical? Is our implementation of type inference practical? a. Estimate the orders of growth of time and space of the annotation and constraints phases with the size of the program being analyzed

…

of generic procedures will ensure that no program that depends on the behavior of the unifier without the addition of segment variables (such as the type inference example) will produce wrong answers as a consequence of this experiment. Indeed, the organization of the unifier in terms of generic procedures makes such experiments

…

setting up and solving symbolic equations for the missing parts of the data. Unification is very powerful, and we showed how to make a simple type-inference engine using unification in this way. We found that the ideas of pattern matching can be extended to operate on general graphs rather than just

…

of the value.9 For example, in the computation of stellar distances described above, intervals are merged to produce better estimates by intersection. In the type-inference example (see section 4.4.2) we combined descriptions by unification to get more specific information. We will examine the general problem of merging values

…

information. This kind of information can be merged using unification, as described in section 4.4. We used unification to implement a simple version of type inference, but it can be used more generally for combining partially specified symbolic expressions. The example of combining records about Ben Franklin in section 4.4

…

compiled into very bad code! Exercise 7.7: Card game puzzle revisited Redo exercise 5.17 using propagators. Exercise 7.8: Type inference In section 4.4.2 we built a type-inference engine as an example of the application of unification matching. In this exercise (which is really a substantial project) we implement

…

type inference taking advantage of propagation. a. Given a Scheme program, construct a propagation network with a cell for every locus that is useful to type. Each

…

variable into such a cell and allowing that variable to accumulate constraints by propagation. This is called “plunking.” Try it. c. In hard cases a type inference may require making guesses (using hypotheticals) and backtracking on discovery of contradictions. Show cases where this is necessary. d. Tracking of premises and reasons enables

…

about why a particular locus has the type that was determined, or why a program could not be consistently typed. e. Is this implementation of type inference practical? Why or why not? If not, how can it be improved? A moral of this story Solving combinatorial puzzles is fun, but it is

…

expanded our pattern-matching tools to allow pattern variables on both sides of a match, implementing unification, which we then used to make an elementary type-inference system. Finally, we built matchers that match arbitrary graphs, not just expression trees, and used graphs and graph matching to express the rules for moves

…

, 321 (ex. 6.3) Parentheses in Scheme, 380, 387 Parti , 5, 299 partial (derivative), 111 Partial information, 4, 130, 157 degeneracy and, 14 propagation, 344 type inference, 193–201 unification, 183, 185 Pattern, 157 partial information, 157, 183 rules and, 157, 160 Pattern-directed invocation, 158, 168–170, 370 n - (negation or

…

–354 model of computation, 327–329 neighbor, 342 partial information, 344 propagator, 342, 346–349 (see also Propagator) scheduler, 342, 343 searching alternatives, 355–364 type inference, 368 (ex. 7.8) unification and, 354 (ex. 7.4) wiring diagram vs. expression, 327, 331 (fig. 7.3), 337 n, 340 (ex. 7.1

…

chess labeling edge to piece, 220, 221 next-turn, 219 turn state variable, 218 type-instantiator, 142, 150, 152 type-properties, 152 Typed expression, 194 Type inference, 193–201 inferred declaration, 195 propagation for, 368 (ex. 7.8) unification for, 196, 200 Types. See also Predicate as type in adventure game, 142

…

, 183–184 as equation solving, 185 partial information and, 183, 185 propagation and, 354 (ex. 7.4) segment variables and, 203–208 substitution instance, 183 type inference and, 193–201 unifier, 183 unifier, 186 unify, 186 unify-constraints, 200 unify:internal, 187 Union types, 202 (ex. 4.16) unit, 311 unit-arithmetic

Tackling TypeScript

by Dr. Axel Rauschmayer · 14 Apr 2020

TypeScript7.1 What you’ll learn 7.2 Specifying the comprehensiveness of type checking 7.3 Types in TypeScript 7.4 Type annotations 7.5 Type inference 7.6 Specifying types via type expressions 7.7 The two language levels: dynamic vs. static 7.8 Type aliases 7.9 Typing Arrays 7

…

Roles played by objects 15.2 Types for objects 15.3 Object vs. object in TypeScript 15.4 Object type literals and interfaces 15.5 Type inference 15.6 Other features of interfaces 15.7 JavaScript’s prototype chains and TypeScript’s types 15.8 Sources of this chapter 16 Class definitions

…

18.3 A generic type for classes: Class<T> 19 Typing Arrays19.1 Roles of Arrays 19.2 Ways of typing Arrays 19.3 Pitfall: type inference doesn’t always get Array types right 19.4 Pitfall: TypeScript assumes indices are never out of bounds 20 Typing functions20.1 Defining statically typed

…

myths 2.3.1 TypeScript code is heavyweight TypeScript code can be very heavyweight. But it doesn’t have to be. For example, due to type inference, we can often get away with few type annotations: function selectionSort(arr: number[]) { // (A) for (let i=0; i<arr.length; i++) { const minIndex = findMinIndex

…

* * * 7.1 What you’ll learn 7.2 Specifying the comprehensiveness of type checking 7.3 Types in TypeScript 7.4 Type annotations 7.5 Type inference 7.6 Specifying types via type expressions 7.7 The two language levels: dynamic vs. static 7.8 Type aliases 7.9 Typing Arrays 7

…

by number Result of toString(): colon followed by string Both number and string are type expressions that specify the types of storage locations. 7.5 Type inference Often, TypeScript can infer a static type if there is no type annotation. For example, if we omit the return type of f(), TypeScript infers

…

that it is string: // %inferred-type: (num: number) => string function toString(num: number) { return String(num); } Type inference is not guesswork: It follows clear rules (similar to arithmetic) for deriving types where they haven’t been specified explicitly. In this case, the return

…

.15.1 Example: Maps Maps are typed generically in TypeScript. For example: const myMap: Map<boolean,string> = new Map([ [false, 'no'], [true, 'yes'], ]); Thanks to type inference (based on the argument of new Map()), we can omit the type parameters: // %inferred-type: Map<boolean, string> const myMap = new Map([ [false, 'no'], [true

…

, too: function id<T>(x: T): T { return x; } We use this function as follows. // %inferred-type: number const num1 = id<number>(123); Due to type inference, we can once again omit the type parameter: // %inferred-type: 123 const num2 = id(123); Note that TypeScript inferred the type 123, which is a

…

signatures: objects as dicts 15.4.6 Interfaces describe instances of Object 15.4.7 Excess property checks: When are extra properties allowed? 15.5 Type inference 15.6 Other features of interfaces 15.6.1 Optional properties 15.6.2 Read-only properties 15.7 JavaScript’s prototype chains and TypeScript

…

invoke this function directly with object literals. TypeScript doesn’t let us do this and we need to use one of the workarounds. 15.5 Type inference These are the types that TypeScript infers for objects that are created via various means: // %inferred-type: Object const obj1 = new Object(); // %inferred-type: any

…

are also Array-ish: interfaces with index signatures 19.3 Pitfall: type inference doesn’t always get Array types right 19.3.1 Inferring types of Arrays is difficult 19.3.2 Type inference for non-empty Array literals 19.3.3 Type inference for empty Array literals 19.3.4 const assertions for Arrays and

…

type inference 19.4 Pitfall: TypeScript assumes indices are never out of bounds * * * In this chapter, we

…

at the same time): interface FirstNamesAndLastName { [index: number]: string; lastName: string; } const ducks: FirstNamesAndLastName = { 0: 'Huey', 1: 'Dewey', 2: 'Louie', lastName: 'Duck', }; 19.3 Pitfall: type inference doesn’t always get Array types right 19.3.1 Inferring types of Arrays is difficult Due to the two roles of Arrays, it is

…

], ]; type Fields = [ [string, 'string', boolean], [string, 'string', boolean], [string, 'number', boolean], ]; type Fields = [ Array<string|boolean>, Array<string|boolean>, Array<string|boolean>, ]; 19.3.2 Type inference for non-empty Array literals When we use non-empty Array literals, TypeScript’s default is to infer list types (not tuple

…

'[number, number]'. [...] func(pair1); We can fix this by adding a type annotation to the const declaration, which avoids type inference: const pair2: [number, number] = [1, 2]; func(pair2); // OK 19.3.3 Type inference for empty Array literals If we initialize a variable with an empty Array literal, then TypeScript initially infers the

…

-error: Argument of type '"abc"' is not assignable to // parameter of type 'number'. (2345) arr.push('abc'); 19.3.4 const assertions for Arrays and type inference We can suffix an Array literal with a const assertion: // %inferred-type: readonly ["igneous", "metamorphic", "sedimentary"] const rockCategories = ['igneous', 'metamorphic', 'sedimentary'] as const; We are

…

seen, a type guard is an operation that returns either true or false – depending on whether its operand meets certain criteria at runtime. TypeScript’s type inference supports type guards by narrowing the static type of an operand when the result is true. 23.2.1 Strict equality (===) Strict equality works as

…

: string) { const dotIndex = filename.lastIndexOf('.'); assert(dotIndex >= 0); // (A) return filename.slice(0, dotIndex); } 23.4.1 TypeScript’s support for assertion functions TypeScript’s type inference provides special support for assertion functions, if we mark such functions with assertion signatures as return types. W.r.t. how and what we can