diff --git a/lib/std/system.nim b/lib/std/system.nim
index bdab856d..179c0518 100644
--- a/lib/std/system.nim
+++ b/lib/std/system.nim
@@ -273,6 +273,8 @@ proc `==`*(x, y: char): bool {.magic: "EqCh", noSideEffect.}
   ## Checks for equality between two `char` variables.
 proc `==`*(x, y: bool): bool {.magic: "EqB", noSideEffect.}
   ## Checks for equality between two `bool` variables.
+proc `==`*[T](x, y: set[T]): bool {.magic: "EqSet", noSideEffect.}
+  ## Checks for equality between two variables of type `set`.
 
 proc `==`*[T](x, y: ref T): bool {.magic: "EqRef", noSideEffect.}
   ## Checks that two `ref` variables refer to the same item.
@@ -288,6 +290,12 @@ proc `<=`*(x, y: char): bool {.magic: "LeCh", noSideEffect.}
   ## Compares two chars and returns true if `x` is lexicographically
   ## before `y` (uppercase letters come before lowercase letters).
 
+proc `<=`*[T](x, y: set[T]): bool {.magic: "LeSet", noSideEffect.}
+  ## Returns true if `x` is a subset of `y`.
+  ##
+  ## A subset `x` has all of its members in `y` and `y` doesn't necessarily
+  ## have more members than `x`. That is, `x` can be equal to `y`.
+
 proc `<=`*(x, y: bool): bool {.magic: "LeB", noSideEffect.}
 proc `<=`*[T](x, y: ref T): bool {.magic: "LePtr", noSideEffect.}
 proc `<=`*(x, y: pointer): bool {.magic: "LePtr", noSideEffect.}
@@ -301,6 +309,12 @@ proc `<`*(x, y: char): bool {.magic: "LtCh", noSideEffect.}
   ## Compares two chars and returns true if `x` is lexicographically
   ## before `y` (uppercase letters come before lowercase letters).
 
+proc `<`*[T](x, y: set[T]): bool {.magic: "LtSet", noSideEffect.}
+  ## Returns true if `x` is a strict or proper subset of `y`.
+  ##
+  ## A strict or proper subset `x` has all of its members in `y` but `y` has
+  ## more elements than `y`.
+
 proc `==`*(x, y: int8): bool {.magic: "EqI", noSideEffect.}
 proc `==`*(x, y: int16): bool {.magic: "EqI", noSideEffect.}
 proc `==`*(x, y: int32): bool {.magic: "EqI", noSideEffect.}
diff --git a/src/hexer/desugar.nim b/src/hexer/desugar.nim
new file mode 100644
index 00000000..1c2961be
--- /dev/null
+++ b/src/hexer/desugar.nim
@@ -0,0 +1,449 @@
+# removes abstractions like set ops and ref object constructors
+
+import std / [assertions]
+include nifprelude
+import ".." / nimony / [nimony_model, decls, programs, typenav, sizeof, expreval, xints]
+import basics
+
+type
+  Context = object
+    counter: int
+    typeCache: TypeCache
+    thisModuleSuffix: string
+    tempUseBufStack: seq[TokenBuf]
+
+proc declareTemp(c: var Context; dest: var TokenBuf; typ: Cursor; info: PackedLineInfo): SymId =
+  let s = "`desugar." & $c.counter & "." & c.thisModuleSuffix
+  inc c.counter
+  result = pool.syms.getOrIncl(s)
+  copyIntoKind dest, VarS, info:
+    dest.addSymDef result, info
+    dest.addDotToken() # export, pragmas
+    dest.addDotToken()
+    copyTree dest, typ # type
+    dest.addDotToken() # value
+
+proc needsTemp(n: Cursor): bool =
+  case n.kind
+  of Symbol, IntLit, UIntLit, FloatLit, CharLit, StringLit:
+    result = false
+  of ParLe:
+    var n = n
+    case n.exprKind
+    of NilX, FalseX, TrueX, InfX, NegInfX, NanX, SizeofX:
+      result = false
+    of ExprX:
+      inc n
+      let first = n
+      skip n
+      if n.kind == ParRi:
+        # single element expr
+        result = needsTemp(first)
+      else:
+        result = true
+    of SufX:
+      inc n
+      result = needsTemp(n)
+    of DconvX:
+      inc n
+      skip n
+      result = needsTemp(n)
+    of AtX, PatX, ArrAtX, TupAtX, DotX, DerefDotX, ParX, AddrX, HaddrX:
+      inc n
+      while n.kind != ParRi:
+        if needsTemp(n):
+          return true
+        skip n
+      result = false
+    else:
+      result = true
+  else:
+    result = true
+
+proc skipParRi(n: var Cursor) =
+  if n.kind == ParRi:
+    inc n
+  else:
+    error "expected ')', but got: ", n
+
+proc tr(c: var Context; dest: var TokenBuf; n: var Cursor)
+
+proc trSons(c: var Context; dest: var TokenBuf; n: var Cursor) =
+  copyInto dest, n:
+    while n.kind != ParRi:
+      tr(c, dest, n)
+
+proc trLocal(c: var Context; dest: var TokenBuf; n: var Cursor) =
+  copyInto dest, n:
+    let name = n.symId
+    takeTree dest, n # name
+    takeTree dest, n # export marker
+    takeTree dest, n # pragmas
+    c.typeCache.registerLocal(name, n)
+    takeTree dest, n # type
+    tr(c, dest, n)
+
+proc trProc(c: var Context; dest: var TokenBuf; n: var Cursor) =
+  c.typeCache.openScope()
+  copyInto dest, n:
+    let sym = n.symId
+    for i in 0..<BodyPos:
+      if i == ParamsPos:
+        c.typeCache.registerParams(sym, n)
+      takeTree dest, n
+    tr(c, dest, n)
+  c.typeCache.closeScope()
+
+proc addUintType(buf: var TokenBuf; bits: int; info: PackedLineInfo) =
+  buf.add tagToken("u", info)
+  buf.addIntLit(bits, info)
+  buf.addParRi()
+
+proc trSetType(c: var Context; dest: var TokenBuf; n: var Cursor) =
+  let info = n.info
+  inc n
+  let sizeOrig = bitsetSizeInBytes(n)
+  var err = false
+  let size = asSigned(sizeOrig, err)
+  if err:
+    error "invalid set element type: ", n
+  else:
+    case size
+    of 1, 2, 4, 8:
+      dest.addUintType(size * 8, info)
+    else:
+      dest.add tagToken("array", info)
+      dest.addUintType(8, info)
+      dest.addIntLit(size, info)
+      dest.addParRi()
+  skip n
+  skipParRi n
+
+proc liftTemp(c: var Context; dest: var TokenBuf; n: Cursor; typ: Cursor; info: PackedLineInfo): Cursor =
+  let tmp = declareTemp(c, dest, typ, n.info)
+  copyIntoKind dest, AsgnS, n.info:
+    dest.add symToken(tmp, n.info)
+    dest.addSubtree n
+  c.tempUseBufStack.add createTokenBuf(4)
+  c.tempUseBufStack[^1].add symToken(tmp, n.info)
+  result = beginRead(c.tempUseBufStack[^1])
+
+proc liftTempAddr(c: var Context; dest: var TokenBuf; n: Cursor; typ: Cursor; info: PackedLineInfo): Cursor =
+  var ptrTypeBuf = createTokenBuf(8)
+  copyIntoKind ptrTypeBuf, PtrT, typ.info:
+    ptrTypeBuf.addSubtree typ
+  let ptrType = beginRead(ptrTypeBuf)
+  let tmp = declareTemp(c, dest, ptrType, n.info)
+  copyIntoKind dest, AsgnS, n.info:
+    dest.add symToken(tmp, n.info)
+    copyIntoKind dest, AddrX, n.info:
+      dest.addSubtree n
+  c.tempUseBufStack.add createTokenBuf(4)
+  copyIntoKind c.tempUseBufStack[^1], DerefX, n.info:
+    c.tempUseBufStack[^1].add symToken(tmp, n.info)
+  result = beginRead(c.tempUseBufStack[^1])
+
+proc genSetOp(c: var Context; dest: var TokenBuf; n: var Cursor) =
+  let info = n.info
+  let kind = n.exprKind
+  inc n
+  let typ = n
+  if typ.typeKind != SetT:
+    error "expected set type for set op", n
+  var baseType = typ
+  inc baseType
+  var argsBuf = createTokenBuf(16)
+  swap dest, argsBuf
+  let typeStart = dest.len
+  trSetType(c, dest, n)
+  let aStart = dest.len
+  tr(c, dest, n)
+  let bStart = dest.len
+  tr(c, dest, n)
+  swap dest, argsBuf
+  skipParRi n
+  let cType = cursorAt(argsBuf, typeStart)
+  let aOrig = cursorAt(argsBuf, aStart)
+  let bOrig = cursorAt(argsBuf, bStart)
+  let useTemp = needsTemp(aOrig) or needsTemp(bOrig)
+  let oldBufStackLen = c.tempUseBufStack.len
+  let a: Cursor
+  let b: Cursor
+  if useTemp:
+    dest.add parLeToken(ExprX, info)
+    # lift both so (n, (n = 123; n)) works
+    a = liftTemp(c, dest, aOrig, typ, info)
+    b = liftTemp(c, dest, bOrig, typ, info)
+  else:
+    a = aOrig
+    b = bOrig
+  var err = false
+  let size = asSigned(bitsetSizeInBytes(baseType), err)
+  assert not err
+  case size
+  of 1, 2, 4, 8:
+    case kind
+    of CardSetX:
+      # XXX needs countBits compilerproc
+      raiseAssert("unimplemented")
+    of LtSetX:
+      copyIntoKind dest, AndX, info:
+        copyIntoKind dest, EqX, info:
+          dest.addSubtree cType
+          copyIntoKind dest, BitAndX, info:
+            dest.addSubtree cType
+            dest.addSubtree a
+            copyIntoKind dest, BitNotX, info:
+              dest.addSubtree cType
+              dest.addSubtree b
+          dest.addIntLit(0, info)
+        copyIntoKind dest, NeqX, info:
+          dest.addSubtree cType
+          dest.addSubtree a
+          dest.addSubtree b
+    of LeSetX:
+      copyIntoKind dest, EqX, info:
+        dest.addSubtree cType
+        copyIntoKind dest, BitAndX, info:
+          dest.addSubtree cType
+          dest.addSubtree a
+          copyIntoKind dest, BitNotX, info:
+            dest.addSubtree cType
+            dest.addSubtree b
+        dest.addIntLit(0, info)
+    of EqSetX:
+      copyIntoKind dest, EqX, info:
+        dest.addSubtree cType
+        dest.addSubtree a
+        dest.addSubtree b
+    of MulSetX:
+      copyIntoKind dest, BitAndX, info:
+        dest.addSubtree cType
+        dest.addSubtree a
+        dest.addSubtree b
+    of PlusSetX:
+      copyIntoKind dest, BitOrX, info:
+        dest.addSubtree cType
+        dest.addSubtree a
+        dest.addSubtree b
+    of MinusSetX:
+      copyIntoKind dest, BitAndX, info:
+        dest.addSubtree cType
+        dest.addSubtree a
+        copyIntoKind dest, BitNotX, info:
+          dest.addSubtree cType
+          dest.addSubtree b
+    of XorSetX:
+      copyIntoKind dest, BitXorX, info:
+        dest.addSubtree cType
+        dest.addSubtree a
+        dest.addSubtree b
+    of InSetX:
+      let mask = size * 8 - 1
+      copyIntoKind dest, NeqX, info:
+        dest.addSubtree cType
+        copyIntoKind dest, BitAndX, info:
+          dest.addSubtree cType
+          dest.addSubtree a
+          copyIntoKind dest, ShlX, info:
+            dest.addSubtree cType
+            copyIntoKind dest, CastX, info:
+              dest.addSubtree cType
+              dest.addIntLit(1, info)
+            copyIntoKind dest, BitAndX, info:
+              dest.addUintType(-1, info)
+              copyIntoKind dest, CastX, info:
+                dest.addUintType(-1, info)
+                dest.addSubtree b
+              dest.addUintLit(uint64(mask), info)
+        dest.addUintLit(0, info)
+    else:
+      raiseAssert("unreachable")
+  else:
+    # XXX implement
+    raiseAssert("unimplemented")
+  if useTemp:
+    dest.addParRi()
+    c.tempUseBufStack.shrink(oldBufStackLen)
+
+proc genSetConstr(c: var Context; dest: var TokenBuf; n: var Cursor) =
+  let info = n.info
+  var typ = c.typeCache.getType(n)
+  var bytes = evalBitSet(n, typ)
+  case bytes.len
+  of 0:
+    # not constant
+    # XXX implement
+    raiseAssert("unimplemented")
+  of 1, 2, 4, 8:
+    # hopefully this is correct?
+    bytes.setLen(8)
+    dest.addUintLit(cast[ptr uint64](addr bytes[0])[], info)
+    skip n
+  else:
+    dest.addParLe(AconstrX, info)
+    #trSetType(c, dest, typ)
+    for b in bytes:
+      dest.addUintLit(b, info)
+
+proc genInclExcl(c: var Context; dest: var TokenBuf; n: var Cursor) =
+  let info = n.info
+  let kind = n.stmtKind
+  inc n
+  let typ = n
+  if typ.typeKind != SetT:
+    error "expected set type for incl/excl", n
+  var baseType = typ
+  inc baseType
+  var argsBuf = createTokenBuf(16)
+  swap dest, argsBuf
+  let typeStart = dest.len
+  trSetType(c, dest, n)
+  let aStart = dest.len
+  tr(c, dest, n)
+  let bStart = dest.len
+  tr(c, dest, n)
+  swap dest, argsBuf
+  skipParRi n
+  let cType = cursorAt(argsBuf, typeStart)
+  let aOrig = cursorAt(argsBuf, aStart)
+  let bOrig = cursorAt(argsBuf, bStart)
+  let useTemp = needsTemp(aOrig) or needsTemp(bOrig)
+  let oldBufStackLen = c.tempUseBufStack.len
+  let a: Cursor
+  let b: Cursor
+  if useTemp:
+    dest.add parLeToken(ExprX, info)
+    # lift both so (n, (n = 123; n)) works
+    a = liftTempAddr(c, dest, aOrig, typ, info)
+    b = liftTemp(c, dest, bOrig, typ, info)
+  else:
+    a = aOrig
+    b = bOrig
+  var err = false
+  let size = asSigned(bitsetSizeInBytes(baseType), err)
+  assert not err
+  case size
+  of 1, 2, 4, 8:
+    let mask = size * 8 - 1
+    copyIntoKind dest, AsgnS, info:
+      dest.addSubtree a
+      if kind == InclSetS:
+        dest.addParLe(BitOrX, info)
+        dest.addSubtree cType
+        dest.addSubtree a
+      else:
+        dest.addParLe(BitAndX, info)
+        dest.addSubtree cType
+        dest.addSubtree a
+        dest.addParLe(BitNotX, info)
+        dest.addSubtree cType
+      copyIntoKind dest, ShlX, info:
+        dest.addSubtree cType
+        copyIntoKind dest, CastX, info:
+          dest.addSubtree cType
+          dest.addIntLit(1, info)
+        copyIntoKind dest, BitAndX, info:
+          dest.addUintType(-1, info)
+          dest.addSubtree b
+          dest.addIntLit(mask, info)
+      if kind == InclSetS:
+        dest.addParRi() # bitor
+      else:
+        dest.addParRi() # bitand
+        dest.addParRi() # bitnot
+  else:
+    template addLhs() =
+      copyIntoKind dest, ArrAtX, info:
+        dest.addSubtree a
+        copyIntoKind dest, ShrX, info:
+          dest.addUintType(-1, info)
+          copyIntoKind dest, CastX, info:
+            dest.addUintType(-1, info)
+            dest.addParRi()
+            dest.addSubtree b
+          dest.addIntLit(3)
+    copyIntoKind dest, AsgnS, info:
+      addLhs()
+      copyIntoKind dest, if kind == InclSetS: BitOrX else: BitAndX, info:
+        addLhs()
+        if kind == ExclSetS:
+          dest.addParLe BitNotX, info
+          dest.addUintType(8, info)
+        copyIntoKind dest, ShlX, info:
+          dest.addUintType(8, info)
+          dest.addUintLit(1, info)
+          copyIntoKind dest, BitAndX, info:
+            dest.addUintType(-1, info)
+            dest.addSubtree b
+            dest.addUintLit(7, info)
+        if kind == ExclSetS:
+          dest.addParRi()
+  if useTemp:
+    dest.addParRi()
+    c.tempUseBufStack.shrink(oldBufStackLen)
+
+proc tr(c: var Context; dest: var TokenBuf; n: var Cursor) =
+  case n.kind
+  of DotToken, UnknownToken, EofToken, Ident, Symbol, SymbolDef, IntLit, UIntLit, FloatLit, CharLit, StringLit:
+    takeTree dest, n
+  of ParLe:
+    case n.exprKind
+    of NoExpr:
+      case n.stmtKind
+      of NoStmt:
+        case n.typeKind
+        of SetT:
+          #trSetType(c, dest, n)
+          # leave this to nifcgen
+          trSons(c, dest, n)
+        else:
+          trSons(c, dest, n)
+      of InclSetS, ExclSetS:
+        genInclExcl(c, dest, n)
+      of CaseS:
+        copyInto dest, n:
+          while n.kind != ParRi:
+            case n.substructureKind
+            of OfS:
+              copyInto dest, n:
+                takeTree dest, n # keep set constructor
+                tr(c, dest, n)
+            else:
+              tr(c, dest, n)
+      of ResultS, LetS, VarS, CursorS, ConstS:
+        trLocal c, dest, n
+      of ProcS, FuncS, MacroS, MethodS, ConverterS:
+        trProc c, dest, n
+      of IterS, TemplateS, TypeS, EmitS, BreakS, ContinueS,
+        ForS, CmdS, IncludeS, ImportS, FromImportS, ImportExceptS,
+        ExportS, CommentS, ClonerS, TracerS, DisarmerS, MoverS, DtorS,
+        PragmasLineS:
+        takeTree dest, n
+      of ScopeS:
+        c.typeCache.openScope()
+        trSons(c, dest, n)
+        c.typeCache.closeScope()
+      else:
+        trSons(c, dest, n)
+    of SetX:
+      genSetConstr(c, dest, n)
+    of PlusSetX, MinusSetX, MulSetX, XorSetX, EqSetX, LeSetX, LtSetX, InSetX, CardSetX:
+      genSetOp(c, dest, n)
+    of NewOconstrX:
+      # XXX `new`
+      raiseAssert("unimplemented")
+    of TypeofX:
+      takeTree dest, n
+    else:
+      trSons(c, dest, n)
+  of ParRi:
+    raiseAssert "unexpected ')' inside"
+
+proc desugar*(n: Cursor; moduleSuffix: string): TokenBuf =
+  var c = Context(counter: 0, typeCache: createTypeCache(), thisModuleSuffix: moduleSuffix)
+  c.typeCache.openScope()
+  result = createTokenBuf(300)
+  var n = n
+  tr c, result, n
+  c.typeCache.closeScope()
diff --git a/src/hexer/nifcgen.nim b/src/hexer/nifcgen.nim
index 556aa6a1..806185af 100644
--- a/src/hexer/nifcgen.nim
+++ b/src/hexer/nifcgen.nim
@@ -452,15 +452,21 @@ proc traverseType(e: var EContext; c: var Cursor; flags: set[TypeFlag] = {}) =
       if err:
         error e, "invalid set element type: ", c
       else:
-        var arrBuf = createTokenBuf(16)
-        arrBuf.add tagToken("array", info)
-        arrBuf.add tagToken("u", info)
-        arrBuf.addIntLit(8, info)
-        arrBuf.addParRi()
-        arrBuf.addIntLit(size, info)
-        arrBuf.addParRi()
-        var arrCursor = cursorAt(arrBuf, 0)
-        traverseAsNamedType(e, arrCursor)
+        case size
+        of 1, 2, 4, 8:
+          e.dest.add tagToken("u", info)
+          e.dest.addIntLit(size * 8, info)
+          e.dest.addParRi()
+        else:
+          var arrBuf = createTokenBuf(16)
+          arrBuf.add tagToken("array", info)
+          arrBuf.add tagToken("u", info)
+          arrBuf.addIntLit(8, info)
+          arrBuf.addParRi()
+          arrBuf.addIntLit(size, info)
+          arrBuf.addParRi()
+          var arrCursor = cursorAt(arrBuf, 0)
+          traverseAsNamedType(e, arrCursor)
       skip c
       skipParRi e, c
     of VoidT, VarargsT, NilT, ConceptT,
@@ -857,8 +863,6 @@ proc traverseExpr(e: var EContext; c: var Cursor) =
         e.dest.addIntLit(0, c.info) # inheritance
         e.dest.add c # add right paren
         inc c # skip right paren
-      of PlusSetX, MinusSetX, MulSetX, XorSetX, EqSetX, LeSetX, LtSetX, InSetX, CardSetX:
-        raiseAssert("unimplemented")
       of DerefDotX:
         e.dest.add tagToken("dot", c.info)
         e.dest.add tagToken("deref", c.info)
@@ -896,6 +900,8 @@ proc traverseExpr(e: var EContext; c: var Cursor) =
           e.dest.add c
           inc c
           wantParRi e, c
+      of NewOconstrX, SetX, PlusSetX, MinusSetX, MulSetX, XorSetX, EqSetX, LeSetX, LtSetX, InSetX, CardSetX:
+        error e, "BUG: not eliminated: ", c
       else:
         e.dest.add c
         inc c
@@ -1152,9 +1158,9 @@ proc traverseStmt(e: var EContext; c: var Cursor; mode = TraverseAll) =
     of BlockS: traverseBlock e, c
     of IfS: traverseIf e, c
     of CaseS: traverseCase e, c
-    of YieldS, ForS:
+    of YieldS, ForS, InclSetS, ExclSetS:
       error e, "BUG: not eliminated: ", c
-    of TryS, RaiseS, InclSetS, ExclSetS:
+    of TryS, RaiseS:
       error e, "BUG: not implemented: ", c
     of FuncS, ProcS, ConverterS, MethodS:
       traverseProc e, c, mode
diff --git a/src/hexer/pipeline.nim b/src/hexer/pipeline.nim
index 64fb486f..3ef5fde1 100644
--- a/src/hexer/pipeline.nim
+++ b/src/hexer/pipeline.nim
@@ -9,7 +9,7 @@
 
 include nifprelude
 
-import basics, iterinliner, xelim, duplifier, lifter, destroyer
+import basics, iterinliner, desugar, xelim, duplifier, lifter, destroyer
 
 proc transform*(c: var EContext; n: Cursor; moduleSuffix: string): TokenBuf =
   var n = n
@@ -18,19 +18,23 @@ proc transform*(c: var EContext; n: Cursor; moduleSuffix: string): TokenBuf =
   var n0 = move c.dest
   var c0 = beginRead(n0)
 
-  let ctx = createLiftingCtx()
-  var n1 = injectDups(c0, ctx)
+  var n1 = desugar(c0, moduleSuffix)
   endRead(n0)
 
   var c1 = beginRead(n1)
-
-  var n2 = lowerExprs(c1, moduleSuffix)
+  let ctx = createLiftingCtx()
+  var n2 = injectDups(c1, ctx)
   endRead(n1)
 
   var c2 = beginRead(n2)
-  result = injectDestructors(c2, ctx)
+
+  var n3 = lowerExprs(c2, moduleSuffix)
   endRead(n2)
 
+  var c3 = beginRead(n3)
+  result = injectDestructors(c3, ctx)
+  endRead(n3)
+
   shrink(result, result.len-1)
   result.add move(ctx[].dest)
   result.addParRi()
diff --git a/src/lib/nifcursors.nim b/src/lib/nifcursors.nim
index ce9f1d73..5d7493a0 100644
--- a/src/lib/nifcursors.nim
+++ b/src/lib/nifcursors.nim
@@ -236,6 +236,9 @@ proc addStrLit*(dest: var TokenBuf; s: string; info = NoLineInfo) =
 proc addIntLit*(dest: var TokenBuf; i: BiggestInt; info = NoLineInfo) =
   dest.add intToken(pool.integers.getOrIncl(i), info)
 
+proc addUintLit*(dest: var TokenBuf; i: BiggestUInt; info = NoLineInfo) =
+  dest.add uintToken(pool.uintegers.getOrIncl(i), info)
+
 proc span*(c: Cursor): int =
   result = 0
   var c = c
diff --git a/src/nimony/expreval.nim b/src/nimony/expreval.nim
index 1fa92b23..fddacd9e 100644
--- a/src/nimony/expreval.nim
+++ b/src/nimony/expreval.nim
@@ -214,7 +214,9 @@ proc enumBounds*(n: Cursor): Bounds =
   result = Bounds(lo: createNan(), hi: createNaN())
   while n.kind != ParRi:
     let enumField = takeLocal(n, SkipFinalParRi)
-    let x = evalOrdinal(nil, enumField.val)
+    var val = enumField.val
+    inc val # skip tuple tag
+    let x = evalOrdinal(nil, val)
     if isNaN(result.lo) or x < result.lo: result.lo = x
     if isNaN(result.hi) or x > result.hi: result.hi = x
 
@@ -311,6 +313,7 @@ proc evalBitSet*(n, typ: Cursor): seq[uint8] =
     return @[]
   result = newSeq[uint8](s)
   var n = n
+  inc n # skip set tag
   while n.kind != ParRi:
     if n.exprKind == RangeX:
       inc n
diff --git a/tests/nimony/sysbasics/tforloops1.nif b/tests/nimony/sysbasics/tforloops1.nif
index cce3a772..e85754d4 100644
--- a/tests/nimony/sysbasics/tforloops1.nif
+++ b/tests/nimony/sysbasics/tforloops1.nif
@@ -76,7 +76,7 @@
     (hconv 11,~16
      (cstring) "countup start\3A %ld\0A") 25 m.1) ,2
    (if 3
-    (elif 11,758,lib/std/system.nim
+    (elif 11,786,lib/std/system.nim
      (expr 2,1
       (lt
        (i -1) 9,26,tests/nimony/sysbasics/tforloops1.nim +5 5,26,tests/nimony/sysbasics/tforloops1.nim x.0)) ~1,1
diff --git a/tests/nimony/sysbasics/tsets.nim b/tests/nimony/sysbasics/tsets.nim
new file mode 100644
index 00000000..a746e4d9
--- /dev/null
+++ b/tests/nimony/sysbasics/tsets.nim
@@ -0,0 +1,13 @@
+type Foo = enum
+  A, B, C, D, E, F
+
+var s, s1: set[Foo]
+s = {A..D}
+s1 = {A..C}
+discard s1 < s
+let y = s1 * s
+let z: set[Foo] = y
+discard y == {A..C}
+discard z == {A..C}
+discard s - s1 == {D}
+discard s1 <= s