   fieldTypes = for typeArgs in typeArgLists
     if typeArgs
       if isRecord typeArgs
-        for type in _snd unzip _labeled _terms typeArgs when type
-          type = typeCompile ctx, type
+        for typeExpression in _snd unzip _labeled _validTerms typeArgs when typeExpression
+          type = typeCompile ctx, typeExpression
           for name, kind of values findFree type
             if not inSet varNameSet, name
-              malformed ctx, type, "Type variable #{name} not declared"
-              throw new Error "Type variable #{name} not declared"
+              malformed ctx, typeExpression, "Type variable #{name} not declared"
             else
               if foundKind = lookupInMap kinds, name
                 if not kindsEq foundKind, kind
-                  malformed ctx, type, "Type variable #{name} must have the same kind"
+                  malformed ctx, typeExpression, "Type variable #{name} must have the same kind"
               else
                 addToMap kinds, name, kind
           type
       else
         malformed ctx, typeArgs, 'Required a record of types'
-        null
-    else
-      null
+        []
+    else
+      []
 
   for typeParam in typeParams
     if not lookupInMap kinds, (_symbol typeParam)
       malformed ctx, typeParam, 'Data type parameter not used'
-      throw new Error 'Data type parameter not used'
+      # throw new Error 'Data type parameter not used'
 
   freshingSub = mapMap ((kind) -> ctx.freshTypeVariable kind), kinds
 

    # Translate
    concat (for [constr, params] in defs
      identifier = validIdentifier constr.symbol
      paramLabels = (_labeled _terms params or []).map(_fst).map(_labelName)
      paramNames = paramLabels.map(validIdentifier)

      constrValue = (jsAssignStatement "#{identifier}._value",

    expression[0].symbol is '('

isRecord = (expression) ->
  (isTuple expression) and (isLabel _fst _terms expression)

isSeq = (expression) ->
  (isForm expression) and expression[0].symbol is '{'
