fix some typos in SIP-23

Author: SethTisue

_sips/sips/2014-06-27-42.type.md

@@ -38,7 +38,7 @@ for full-spectrum dependent types.
 
 Scala's semantics have up until now been richer than its syntax. The only singleton types which are
 currently _directly_ expressible are those of the form `p.type` where `p` is a path pointing to a
-value of some subtype of `AnyRef`. Interally the Scala compiler also represents singleton types for
+value of some subtype of `AnyRef`. Internally the Scala compiler also represents singleton types for
 individual values of subtypes of `AnyVal`, such as `Int` or values of type `String` which don't
 correspond to paths. These types are inferred in some circumstances, notably as the types of `final`
 vals. Their primary purpose has been to represent compile time constants (see [6.24 Constant
@@ -49,13 +49,13 @@ The types here correspond to _literal_ values (ie. values which programmers can
 terms, see [1.3
 Literals](http://scala-lang.org/files/archive/spec/2.12/01-lexical-syntax.html#literals)) such as
 `23`, `true` or `"foo"` of the larger non-singleton types they inhabit (`Int`, `Boolean` or `String`
-respectively). However, there is no suface syntax to express these types.
+respectively). However, there is no surface syntax to express these types.
 
 As we will see in the motivation section of the proposal below, singleton types corresponding to
 literal values (henceforth _literal types_) have many important uses and are already widely used in
 many important Scala libraries. The lack of first class syntax for literal types has forced library
 authors to use the experimental Scala macro system to provide a means to express them. Whilst this
-has proved to be extremely successful, it has poor ergonimics (although this can typically be hidden
+has proved to be extremely successful, it has poor ergonomics (although this can typically be hidden
 from library _users_) and is not portable -- because Scala macros in general and the mechanisms used
 to expose literal types to Scala programmes in particular depend on internal implementation details
 of the current Scala compiler.