@harmoniclabs/pebble 0.1.0-dev7 → 0.1.0-dev8

package/dist/IR/IRNodes/IRConst.js

@@ -2,7 +2,6 @@ import { Pair } from "@harmoniclabs/pair";
 import { isData, dataToCbor } from "@harmoniclabs/plutus-data";
 import { fromUtf8, toHex } from "@harmoniclabs/uint8array-utils";
 import { BasePlutsError } from "../../utils/BasePlutsError.js";
-import UPLCFlatUtils from "../../utils/UPLCFlatUtils/index.js";
 import { concatUint8Arr } from "../utils/concatUint8Arr.js";
 import { positiveBigIntAsBytes } from "../utils/positiveIntAsBytes.js";
 import { isIRParentTerm } from "../utils/isIRParentTerm.js";
@@ -27,6 +26,7 @@ import { TirStringT } from "../../compiler/tir/types/TirNativeType/native/string
 import { TirVoidT } from "../../compiler/tir/types/TirNativeType/native/void.js";
 import { hashIrData, isIRHash } from "../IRHash.js";
 import { ByteString } from "@harmoniclabs/bytestring";
+import { UPLCFlatUtils } from "../../utils/UPLCFlatUtils/index.js";
 export function isIRConstPair(value) {
     return (value instanceof Pair &&
         isIRConstValue(value.fst) &&

package/dist/IR/IRNodes/IRNative/IRNativeTag.d.ts

@@ -96,11 +96,10 @@ export declare enum IRNativeTag {
     _dropList = -4,
     _foldr = -6,
     _foldl = -7,
-    _mkFindDataOptional = -8,
     _length = -9,
     _some = -10,
     _every = -11,
-    _mkFilter = -12,
+    _filter = -12,
     _id = -15,
     _not = -16,
     _strictAnd = -17,
@@ -133,6 +132,8 @@ export declare enum IRNativeTag {
     _isZero = -42,
     _sortedValueLovelaces = -43,
     _getCredentialsHash = -44,
-    _findSopOptional = -45
+    _findSopOptional = -45,
+    _increment = -46,
+    _decrement = -47
 }
 export declare function nativeTagToString(nativeTag: IRNativeTag): string;

package/dist/IR/IRNodes/IRNative/IRNativeTag.js

@@ -116,11 +116,11 @@ export var IRNativeTag;
     IRNativeTag[IRNativeTag["_dropList"] = -4] = "_dropList";
     IRNativeTag[IRNativeTag["_foldr"] = -6] = "_foldr";
     IRNativeTag[IRNativeTag["_foldl"] = -7] = "_foldl";
-    IRNativeTag[IRNativeTag["_mkFindDataOptional"] = -8] = "_mkFindDataOptional";
+    //     _mkFindDataOptional               = -8,
     IRNativeTag[IRNativeTag["_length"] = -9] = "_length";
     IRNativeTag[IRNativeTag["_some"] = -10] = "_some";
     IRNativeTag[IRNativeTag["_every"] = -11] = "_every";
-    IRNativeTag[IRNativeTag["_mkFilter"] = -12] = "_mkFilter";
+    IRNativeTag[IRNativeTag["_filter"] = -12] = "_filter";
     // _fstPair            = -13,
     // _sndPair            = -14,
     IRNativeTag[IRNativeTag["_id"] = -15] = "_id";
@@ -156,6 +156,8 @@ export var IRNativeTag;
     IRNativeTag[IRNativeTag["_sortedValueLovelaces"] = -43] = "_sortedValueLovelaces";
     IRNativeTag[IRNativeTag["_getCredentialsHash"] = -44] = "_getCredentialsHash";
     IRNativeTag[IRNativeTag["_findSopOptional"] = -45] = "_findSopOptional";
+    IRNativeTag[IRNativeTag["_increment"] = -46] = "_increment";
+    IRNativeTag[IRNativeTag["_decrement"] = -47] = "_decrement";
 })(IRNativeTag || (IRNativeTag = {}));
 Object.freeze(IRNativeTag);
 export function nativeTagToString(nativeTag) {
@@ -165,12 +167,12 @@ export function nativeTagToString(nativeTag) {
         case IRNativeTag._dropList: return "dropList";
         case IRNativeTag._foldr: return "foldr";
         case IRNativeTag._foldl: return "foldl";
-        case IRNativeTag._mkFindDataOptional: return "mkFind";
+        // case IRNativeTag._mkFindDataOptional          : return "mkFind";
         case IRNativeTag._findSopOptional: return "findSopOptional";
         case IRNativeTag._length: return "length";
         case IRNativeTag._some: return "some";
         case IRNativeTag._every: return "every";
-        case IRNativeTag._mkFilter: return "mkFilter";
+        case IRNativeTag._filter: return "mkFilter";
         // case IRNativeTag._fstPair       : return "fstPair";
         // case IRNativeTag._sndPair       : return "sndPair";
         case IRNativeTag._id: return "id";
@@ -199,6 +201,8 @@ export function nativeTagToString(nativeTag) {
         case IRNativeTag._isZero: return "isZero";
         case IRNativeTag._sortedValueLovelaces: return "sortedValueLovelaces";
         case IRNativeTag._getCredentialsHash: return "getCredentialHash";
+        case IRNativeTag._increment: return "increment";
+        case IRNativeTag._decrement: return "decrement";
         default: return "";
     }
 }

package/dist/IR/IRNodes/IRNative/index.d.ts

@@ -131,11 +131,10 @@ export declare class IRNative implements IIRTerm, Cloneable<IRNative>, IIRParent
     static get _dropList(): IRNative;
     static get _foldr(): IRNative;
     static get _foldl(): IRNative;
-    static get _mkFindDataOptional(): IRNative;
     static get _length(): IRNative;
     static get _some(): IRNative;
     static get _every(): IRNative;
-    static get _mkFilter(): IRNative;
+    static get _filter(): IRNative;
     static get _id(): IRNative;
     static get _not(): IRNative;
     static get _strictAnd(): IRNative;
@@ -162,6 +161,9 @@ export declare class IRNative implements IIRTerm, Cloneable<IRNative>, IIRParent
     static get _amountOfValue(): IRNative;
     static get _sortedValueLovelaces(): IRNative;
     static get _getCredentialsHash(): IRNative;
+    static get _increment(): IRNative;
+    static get _decrement(): IRNative;
+    static get _isZero(): IRNative;
     static equals(type: TirType): IRTerm;
     static equalListOf(type: TirType): IRHoisted;
 }

package/dist/IR/IRNodes/IRNative/index.js

@@ -184,11 +184,11 @@ export class IRNative {
     static get _dropList() { return new IRNative(IRNativeTag._dropList); }
     static get _foldr() { return new IRNative(IRNativeTag._foldr); }
     static get _foldl() { return new IRNative(IRNativeTag._foldl); }
-    static get _mkFindDataOptional() { return new IRNative(IRNativeTag._mkFindDataOptional); }
+    // static get _mkFindDataOptional() { return new IRNative( IRNativeTag._mkFindDataOptional ); }
     static get _length() { return new IRNative(IRNativeTag._length); }
     static get _some() { return new IRNative(IRNativeTag._some); }
     static get _every() { return new IRNative(IRNativeTag._every); }
-    static get _mkFilter() { return new IRNative(IRNativeTag._mkFilter); }
+    static get _filter() { return new IRNative(IRNativeTag._filter); }
     // static get _fstPair() { return new IRNative( IRNativeTag._fstPair ); }
     // static get _sndPair() { return new IRNative( IRNativeTag._sndPair ); }
     static get _id() { return new IRNative(IRNativeTag._id); }
@@ -217,6 +217,9 @@ export class IRNative {
     static get _amountOfValue() { return new IRNative(IRNativeTag._amountOfValue); }
     static get _sortedValueLovelaces() { return new IRNative(IRNativeTag._sortedValueLovelaces); }
     static get _getCredentialsHash() { return new IRNative(IRNativeTag._getCredentialsHash); }
+    static get _increment() { return new IRNative(IRNativeTag._increment); }
+    static get _decrement() { return new IRNative(IRNativeTag._decrement); }
+    static get _isZero() { return new IRNative(IRNativeTag._isZero); }
     static equals(type) {
         type = getUnaliased(type);
         if (type instanceof TirAliasType)

package/dist/IR/toUPLC/CompilerOptions.d.ts

@@ -24,7 +24,7 @@ export interface CompilerOptions {
     /**
      * path to the entry file
      */
-    readonly entry: string;
+    entry: string;
     /**
      * path of the root of the project
      */

package/dist/IR/toUPLC/CompilerOptions.js

@@ -69,7 +69,8 @@ export const defaultOptions = Object.freeze({
     ...productionOptions,
 });
 export const testOptions = Object.freeze({
-    ...debugOptions,
+    // ...debugOptions,
+    ...productionOptions,
     silent: true
 });
 export const defulatCompilerOptions = defaultOptions;

package/dist/IR/toUPLC/compileIRToUPLC.js

@@ -31,7 +31,7 @@ export function compileIRToUPLC(term, paritalOptions = defaultOptions) {
     // ------------------------------------------------------------------------- //
     ///////////////////////////////////////////////////////////////////////////////
     const options = completeCompilerOptions(paritalOptions);
-    const debugAsserts = options.debugAsserts ?? false;
+    // const debugAsserts = (options as any).debugAsserts ?? false;
     // unwrap top level letted and hoisted;
     while (term instanceof IRLetted || term instanceof IRHoisted) {
         // replace with value
@@ -39,33 +39,24 @@ export function compileIRToUPLC(term, paritalOptions = defaultOptions) {
         // forget the parent; this is the new root
         term.parent = undefined;
     }
-    debugAsserts && _debug_assertions(term);
+    // debugAsserts && _debug_assertions( term );
+    ///////////////////////////////////////////////////////////////////////////////
+    // ------------------------------------------------------------------------- //
+    // ----------------------------- optimizations ----------------------------- //
+    // ------------------------------------------------------------------------- //
+    ///////////////////////////////////////////////////////////////////////////////
     // term = preEvaluateDefinedTermsAndReturnRoot( term );
     term = rewriteNativesAppliedToConstantsAndReturnRoot(term);
-    debugAsserts && _debug_assertions(term);
+    // debugAsserts && _debug_assertions( term );
     // removing unused variables BEFORE going into the rest of the compilation
     // helps letted terms to find a better spot (and possibly be inlined instead of hoisted)
     term = removeUnusedVarsAndReturnRoot(term);
-    debugAsserts && _debug_assertions(term);
+    // debugAsserts && _debug_assertions( term );
     _makeAllNegativeNativesHoisted(term);
-    ///////////////////////////////////////////////////////////////////////////////
-    // ------------------------------------------------------------------------- //
-    // ----------------------------- optimizations ----------------------------- //
-    // ------------------------------------------------------------------------- //
-    ///////////////////////////////////////////////////////////////////////////////
-    // --------------------- optimize recursive functions  --------------------- //
-    // avoid passing whole structs
-    // take letted terms outside
-    // ----------------------- optimize normal functions ----------------------- //
-    // avoid passing whole structs
-    // reorganize function arguments to take advantage of partial applicaiton
-    ///////////////////////////////////////////////////////////////////////////////
-    // ------------------------------------------------------------------------- //
-    // ------------------------------ final steps ------------------------------ //
-    // ------------------------------------------------------------------------- //
-    ///////////////////////////////////////////////////////////////////////////////
     term = replaceNativesAndReturnRoot(term);
-    debugAsserts && _debug_assertions(term);
+    // re-call rewrite to optimize introduced hoisted
+    term = rewriteNativesAppliedToConstantsAndReturnRoot(term);
+    // debugAsserts && _debug_assertions( term );
     // unwrap top level letted and hoisted;
     // some natives may be converted to hoisted;
     // this is really just an edge case
@@ -79,31 +70,39 @@ export function compileIRToUPLC(term, paritalOptions = defaultOptions) {
         term instanceof IRConst // while we are at it
     )
         return term.toUPLC();
+    ///////////////////////////////////////////////////////////////////////////////
+    // ------------------------------------------------------------------------- //
+    // ------------------------------- hoisting -------------------------------- //
+    // ------------------------------------------------------------------------- //
+    ///////////////////////////////////////////////////////////////////////////////
+    // hoist `(force (builtin ifThenElse))` or `(force (force (builtin fstPair)))` etc
     replaceForcedNativesWithHoisted(term);
-    debugAsserts && _debug_assertions(term);
+    // debugAsserts && _debug_assertions( term );
     if (options.delayHoists)
         replaceHoistedWithLetted(term);
     else
         replaceClosedLettedWithHoisted(term);
-    debugAsserts && _debug_assertions(term);
-    if (debugAsserts
-        && options.delayHoists
-        && includesNode(term, node => node instanceof IRHoisted)) {
-        throw new Error("debug assertion failed: hoisted nodes found while delayHoists is true");
-    }
+    // debugAsserts && _debug_assertions( term );
+    // if(
+    //     // debugAsserts
+    //     && options.delayHoists
+    //     && includesNode( term, node => node instanceof IRHoisted )
+    // ) {
+    //     throw new Error("debug assertion failed: hoisted nodes found while delayHoists is true");
+    // }
     // handle letted before hoisted because the tree is smaller
     // and we also have less letted dependecies to handle
     term = handleLettedAndReturnRoot(term);
-    debugAsserts && _debug_assertions(term);
+    // debugAsserts && _debug_assertions( term );
     term = handleHoistedAndReturnRoot(term);
-    debugAsserts && _debug_assertions(term);
+    // debugAsserts && _debug_assertions( term );
     // replaced hoisted terms might include new letted terms
     while (includesNode(term, node => node instanceof IRLetted
         || node instanceof IRHoisted)) {
         term = handleLettedAndReturnRoot(term);
         term = handleHoistedAndReturnRoot(term);
     }
-    debugAsserts && _debug_assertions(term);
+    // debugAsserts && _debug_assertions( term );
     ///////////////////////////////////////////////////////////////////////////////
     // ------------------------------------------------------------------------- //
     // --------------------------- translate to UPLC --------------------------- //
@@ -117,13 +116,13 @@ export function compileIRToUPLC(term, paritalOptions = defaultOptions) {
     // if( options.delayHoists ) replaceHoistedWithLetted( term );
     // handle new hoisted terms
     term = handleHoistedAndReturnRoot(term);
-    debugAsserts && _debug_assertions(term);
+    // debugAsserts && _debug_assertions( term );
     // strictly necessary to check the options
     // otherwise forced natives where already hoisted
     // will be re-hosited; causeing uselsess evaluations
     if (!options.delayHoists)
         term = hoistForcedNatives(term);
-    debugAsserts && _debug_assertions(term);
+    // debugAsserts && _debug_assertions( term );
     // at this point we expect the IR to be translable 1:1 to UPLC
     // The loop is needed because after inlining some params, 
     // new params in outer (or sibling) functions can become 
@@ -161,7 +160,7 @@ export function compileIRToUPLC(term, paritalOptions = defaultOptions) {
     //     irJson.text,
     //     JSON.stringify( onlyHoistedAndLetted( irJson ) )
     // );
-    debugAsserts && _debug_assertions(term);
+    // debugAsserts && _debug_assertions( term );
     // const srcmap = {};
     const uplc = term.toUPLC(ToUplcCtx.root());
     if (!isClosedTerm(uplc)) {

package/dist/IR/toUPLC/subRoutines/handleLetted/index.js

@@ -4,7 +4,7 @@ import { getSortedLettedSet, getLettedTerms, IRLetted } from "../../../IRNodes/I
 import { IRVar } from "../../../IRNodes/IRVar.js";
 import { _modifyChildFromTo } from "../../_internal/_modifyChildFromTo.js";
 import { findAllNoHoisted } from "../../_internal/findAll.js";
-import { getMaxScope } from "./groupByScope.js";
+import { getMaxScope, getUnboundedVars } from "./groupByScope.js";
 import { IRDelayed } from "../../../IRNodes/IRDelayed.js";
 import { lowestCommonAncestor } from "../../_internal/lowestCommonAncestor.js";
 import { isIRTerm } from "../../../utils/isIRTerm.js";
@@ -47,9 +47,22 @@ export function handleLettedAndReturnRoot(term) {
         //
         // hence why `pop` (and not `shift`)
         const { letted, nReferences } = sortedLettedSet.pop();
+        // const shouldLog = (
+        //     letted.value instanceof IRApp
+        //     && letted.value.fn instanceof IRNative
+        //     && letted.value.fn.tag === IRNativeTag.addInteger
+        //     && letted.value.arg instanceof IRConst
+        //     && letted.value.arg.value === -1n
+        // )
         // shouldLog && // console.log("nReferences", nReferences);
         // console.log(` ------------------ working with ${lettedToStr(letted)} ------------------ `);
-        if (nReferences === 1) {
+        // console.log(` ------------------ working with ${lettedToStr(letted)} ------------------ `);
+        // if( shouldLog ) {
+        //     console.log( prettyIRInline( letted ) );
+        // }
+        const wasSingleReferenceButRecursive = nReferences <= 1;
+        if (wasSingleReferenceButRecursive // nReferences <= 1
+            && !someParentIsRecursive(letted)) {
             // console.log("inlining letted (single reference) with value", prettyIRText( letted.value ) )
             _modifyChildFromTo(letted.parent, letted, letted.value);
             continue;
@@ -81,7 +94,9 @@ export function handleLettedAndReturnRoot(term) {
             continue;
         }
         // just in case
-        if (sameLettedRefs.length === 1 && !minScope) {
+        if (sameLettedRefs.length === 1
+            && !minScope
+            && !wasSingleReferenceButRecursive) {
             // console.log("inlining letted (single reference pedantic) with value", prettyIRText( letted.value ) )
             _modifyChildFromTo(letted.parent, letted, letted.value);
             continue;
@@ -108,6 +123,47 @@ export function handleLettedAndReturnRoot(term) {
             }
             ;
         }
+        if (wasSingleReferenceButRecursive) {
+            // OPTIMIZATION:
+            // TODO:
+            // see the general case below
+            const unbounded = getUnboundedVars(letted.value);
+            if (unbounded.size === 0) {
+                // if closed
+                // handle as hoisted
+                for (const ref of sameLettedRefs) {
+                    _modifyChildFromTo(ref.parent, ref, new IRVar(ref.name));
+                }
+                term = new IRApp(new IRFunc([letted.name], term), letted.value);
+                continue;
+            }
+            // else find highest common ancestor where all unbounded vars are defined
+            // OPTIMIZATION:
+            // TODO:
+            // only hoist outside the highest, but fully defined, IRRecursive
+            // and NOT the highest overall
+            // otherwise we risk paying for introducing stuff we don't use
+            let tmp = lca;
+            // let lowestOutsideRecursive: IRTerm = lca;
+            while (tmp = tmp.parent) {
+                if (tmp instanceof IRDelayed) {
+                    lca = tmp;
+                    // lowestOutsideRecursive = tmp;
+                    continue;
+                }
+                if (tmp instanceof IRFunc || tmp instanceof IRRecursive) {
+                    if (tmp.params.some(p => unbounded.has(p))) {
+                        // some parameter is defined here
+                        // so we stop
+                        break;
+                    }
+                    else
+                        lca = tmp;
+                    // else lowestOutsideRecursive = tmp;
+                }
+            }
+            // lca = lowestOutsideRecursive;
+        }
         if (!isIRTerm(lca)) {
             throw new Error("letting nodes with hash " + irHashToHex(lettedHash) + " from different trees");
         }
@@ -176,3 +232,13 @@ function handleLettedAsHoistedAndReturnRoot(letted, lca, sameLettedRefs, current
     }
     return currentRoot;
 }
+function someParentIsRecursive(term) {
+    let parent;
+    ;
+    while (parent = term.parent) {
+        if (parent instanceof IRRecursive)
+            return true;
+        term = parent;
+    }
+    return false;
+}

package/dist/IR/toUPLC/subRoutines/replaceNatives/nativeToIR.d.ts

@@ -28,7 +28,7 @@ export declare const hoisted_strictAnd: IRHoisted;
 export declare const hoisted_strictOr: IRHoisted;
 export declare const hoisted_some: IRHoisted;
 export declare const hoisted_every: IRHoisted;
-export declare const hoisted_mkFilter: IRHoisted;
+export declare const hoisted_filter: IRHoisted;
 export declare const hoisted_gtBS: IRHoisted;
 export declare const hoisted_gtEqBS: IRHoisted;
 export declare const hoisted_gtInt: IRHoisted;

package/dist/IR/toUPLC/subRoutines/replaceNatives/nativeToIR.js

@@ -12,7 +12,7 @@ import { IRRecursive } from "../../../IRNodes/IRRecursive.js";
 import { IRSelfCall } from "../../../IRNodes/IRSelfCall.js";
 import { IRError } from "../../../IRNodes/IRError.js";
 import { _ir_apps } from "../../../IRNodes/IRApp.js";
-import { _ir_let } from "../../../tree_utils/_ir_let.js";
+import { _ir_let, _ir_let_sym } from "../../../tree_utils/_ir_let.js";
 import { _ir_lazyChooseList } from "../../../tree_utils/_ir_lazyChooseList.js";
 import { _ir_lazyIfThenElse } from "../../../tree_utils/_ir_lazyIfThenElse.js";
 import { hoisted_drop4, hoisted_drop2, hoisted_drop3 } from "../_comptimeDropN.js";
@@ -156,13 +156,21 @@ const every_head = Symbol("head");
 const every_tail = Symbol("tail");
 export const hoisted_every = new IRHoisted(new IRFunc([every_pred], _ir_apps(hoisted_recursiveList.clone(), new IRFunc([every_dummy], new IRDelayed(IRConst.bool(true))), new IRFunc([every_self, every_head, every_tail], new IRForced(_ir_apps(hoisted_strictAnd.clone(), new IRDelayed(new IRApp(new IRVar(every_pred), new IRVar(every_head))), new IRDelayed(new IRApp(new IRVar(every_self), new IRVar(every_tail)))))))));
 hoisted_every.hash;
-// hoisted _mkFilter
-const filt_pnil = Symbol("pnilOfType");
+// hoisted _filter
 const filt_pred = Symbol("predicate");
+const filt_self = Symbol("filter_self");
+const filt_list = Symbol("list");
 const filt_elem = Symbol("elem");
-const filt_acc = Symbol("accum");
-export const hoisted_mkFilter = new IRHoisted(new IRFunc([filt_pnil, filt_pred], _ir_apps(hoisted_foldr.clone(), new IRFunc([filt_elem, filt_acc], new IRForced(_ir_apps(IRNative.strictIfThenElse, new IRApp(new IRVar(filt_pred), new IRVar(filt_elem)), new IRDelayed(_ir_apps(IRNative.mkCons, new IRVar(filt_elem), new IRVar(filt_acc))), new IRDelayed(new IRVar(filt_acc))))), new IRVar(filt_pnil))));
-hoisted_mkFilter.hash;
+export const hoisted_filter = new IRHoisted(new IRFunc([filt_pred], new IRRecursive(filt_self, new IRFunc([filt_list], _ir_lazyChooseList(new IRVar(filt_list), 
+// case nil
+new IRVar(filt_list), // nil
+// case cons
+_ir_let_sym(filt_elem, _ir_apps(IRNative.headList, new IRVar(filt_list)), _ir_lazyIfThenElse(_ir_apps(new IRVar(filt_pred), new IRVar(filt_elem)), 
+// then => cons(elem, self(tail))
+_ir_apps(IRNative.mkCons, new IRVar(filt_elem), _ir_apps(new IRSelfCall(filt_self), _ir_apps(IRNative.tailList, new IRVar(filt_list)))), 
+// else => self(tail)
+_ir_apps(new IRSelfCall(filt_self), _ir_apps(IRNative.tailList, new IRVar(filt_list))))))))));
+hoisted_filter.hash;
 // comparison & conversion hoisted (previously inline)
 const gtbs_a = Symbol("a"), gtbs_b = Symbol("b");
 export const hoisted_gtBS = new IRHoisted(new IRFunc([gtbs_a, gtbs_b], _ir_apps(IRNative.lessThanByteString, new IRVar(gtbs_b), new IRVar(gtbs_a))));
@@ -211,12 +219,12 @@ export function nativeToIR(native) {
     switch (native.tag) {
         case IRNativeTag._foldr: return hoisted_foldr.clone();
         case IRNativeTag._foldl: return hoiseted_foldl.clone();
-        case IRNativeTag._mkFindDataOptional: return hoisted_mkFindDataOptional.clone();
+        // case IRNativeTag._mkFindDataOptional: return hoisted_mkFindDataOptional.clone();
         case IRNativeTag._findSopOptional: return hoisted_findSopOptional.clone();
         case IRNativeTag._length: return hoisted_length.clone();
         case IRNativeTag._some: return hoisted_some.clone();
         case IRNativeTag._every: return hoisted_every.clone();
-        case IRNativeTag._mkFilter: return hoisted_mkFilter.clone();
+        case IRNativeTag._filter: return hoisted_filter.clone();
         case IRNativeTag._id: return hoisted_id.clone();
         case IRNativeTag._not: return hoisted_not.clone();
         case IRNativeTag._strictAnd: return hoisted_strictAnd.clone();
@@ -239,6 +247,8 @@ export function nativeToIR(native) {
         case IRNativeTag._getCredentialsHash: return hoisted_getCredentialsHash.clone();
         case IRNativeTag._dropList: return hoisted_dropList.clone();
         case IRNativeTag._mkMapList: return hoisted_mkMapList.clone();
+        case IRNativeTag._increment: return hoisted_addOne.clone();
+        case IRNativeTag._decrement: return hoisted_subOne.clone();
         // case IRNativeTag._mkEqualsList: return hoisted_mkEqualsList.clone();
         default:
             throw new Error("unknown (negative) native calling 'nativeToIR'; " +
@@ -260,7 +270,7 @@ IRConst.bool(false),
 // both lists are cons
 _ir_strictAnd(_ir_apps(new IRVar(eqList_eqFunc), new IRApp(IRNative.headList, new IRVar(eqList_listA)), new IRApp(IRNative.headList, new IRVar(eqList_listB))), _ir_apps(new IRSelfCall(eqList_self), new IRApp(IRNative.tailList, new IRVar(eqList_listA)), new IRApp(IRNative.tailList, new IRVar(eqList_listB))))))))));
 hoisted_mkEqualsList.hash;
-// (nil of type) => ( a => b ) => [a] => [b]
+// (nil of type) [b] => ( a => b ) => [a] => [b]
 const mkMap_nil = Symbol("nilOfType");
 const mkMap_mapFunc = Symbol("mapFunc");
 const mkMap_map = Symbol("map_self");

package/dist/IR/toUPLC/subRoutines/rewriteNativesAppliedToConstantsAndReturnRoot.js

@@ -1,3 +1,5 @@
+import { TirBoolT, TirIntT } from "../../../compiler/tir/types/TirNativeType/index.js";
+import { equalIrHash } from "../../IRHash.js";
 import { _ir_apps } from "../../IRNodes/IRApp.js";
 import { IRConst } from "../../IRNodes/IRConst.js";
 import { IRFunc } from "../../IRNodes/IRFunc.js";
@@ -9,13 +11,25 @@ import { IRVar } from "../../IRNodes/IRVar.js";
 import { _modifyChildFromTo } from "../_internal/_modifyChildFromTo.js";
 import { getApplicationTerms } from "../utils/getApplicationTerms.js";
 import { _compTimeDropN } from "./_comptimeDropN.js";
+import { hoisted_isZero, hoisted_length, hoisted_not } from "./replaceNatives/nativeToIR.js";
 export function rewriteNativesAppliedToConstantsAndReturnRoot(term) {
     // traverse the tree, find applications of natives to constants
     // and replace them with the optimized equivalent
     const stack = [term];
+    function modifyTermAndPushToReprocess(current, newTerm) {
+        const parent = current.parent;
+        if (parent) {
+            _modifyChildFromTo(parent, current, newTerm);
+        }
+        else {
+            term = newTerm;
+            term.parent = undefined;
+        }
+        stack.unshift(newTerm); // reprocess new term for further optimizations (if any)
+    }
     while (stack.length > 0) {
         const current = stack.pop();
-        const parent = current.parent;
+        // const parent = current.parent;
         const appTerms = getApplicationTerms(current);
         if (!appTerms) {
             stack.unshift(...current.children());
@@ -25,16 +39,196 @@ export function rewriteNativesAppliedToConstantsAndReturnRoot(term) {
         const [fstArg, ...restArgs] = args;
         if (isId(func)
             && restArgs.length === 0) {
-            if (parent) {
-                _modifyChildFromTo(parent, current, fstArg);
-            }
-            else {
-                term = fstArg;
-                term.parent = undefined;
-            }
-            stack.unshift(fstArg);
+            modifyTermAndPushToReprocess(current, fstArg);
             continue;
         }
+        if (func instanceof IRNative) {
+            const tag = func.tag;
+            if (tag === IRNativeTag.strictIfThenElse
+                && restArgs.length === 2) {
+                const conditionArg = fstArg;
+                const condtionAppTerms = getApplicationTerms(conditionArg);
+                if (!condtionAppTerms) {
+                    const boolValue = getConstBool(conditionArg);
+                    if (typeof boolValue === "boolean") {
+                        const newTerm = boolValue ? restArgs[0] : restArgs[1];
+                        modifyTermAndPushToReprocess(current, newTerm);
+                        continue;
+                    }
+                    stack.unshift(...current.children()); // normal processing
+                    continue;
+                }
+                const { func: condFunc, args: condArgs } = condtionAppTerms;
+                const thenArg = restArgs[0];
+                const elseArg = restArgs[1];
+                if (isNot(condFunc)
+                    && condArgs.length === 1) {
+                    // replace with swapped branches
+                    const newTerm = _ir_apps(IRNative.strictIfThenElse, condArgs[0], elseArg, thenArg);
+                    modifyTermAndPushToReprocess(current, newTerm);
+                    continue;
+                }
+                else if (isLessThanOrEqualInteger(condFunc)
+                    && condArgs.length === 2) {
+                    const [lhs, rhs] = condArgs;
+                    const lhsInt = getConstInt(lhs);
+                    const rhsInt = getConstInt(rhs);
+                    if (typeof lhsInt === "bigint" && typeof rhsInt === "bigint") {
+                        // replace with constant
+                        const newTerm = (lhsInt <= rhsInt) ? thenArg : elseArg;
+                        modifyTermAndPushToReprocess(current, newTerm);
+                        continue;
+                    }
+                    else if (typeof lhsInt === "bigint") {
+                        const newTerm = _ir_apps(IRNative.strictIfThenElse, _ir_apps(new IRHoisted(_ir_apps(IRNative.lessThanEqualInteger, lhs)), rhs), thenArg, elseArg);
+                        modifyTermAndPushToReprocess(current, newTerm);
+                        continue;
+                    }
+                    else if (typeof rhsInt === "bigint") {
+                        const newTerm = _ir_apps(IRNative.strictIfThenElse, _ir_apps(new IRHoisted(_ir_apps(IRNative.lessThanInteger, rhs)), lhs), elseArg, thenArg);
+                        modifyTermAndPushToReprocess(current, newTerm);
+                        continue;
+                    }
+                }
+                else if (isLessThanInteger(condFunc)
+                    && condArgs.length === 2) {
+                    const [lhs, rhs] = condArgs;
+                    const lhsInt = getConstInt(lhs);
+                    const rhsInt = getConstInt(rhs);
+                    if (typeof lhsInt === "bigint" && typeof rhsInt === "bigint") {
+                        // replace with constant
+                        const newTerm = (lhsInt < rhsInt) ? thenArg : elseArg;
+                        modifyTermAndPushToReprocess(current, newTerm);
+                        continue;
+                    }
+                    else if (typeof lhsInt === "bigint") {
+                        const newTerm = _ir_apps(IRNative.strictIfThenElse, _ir_apps(new IRHoisted(_ir_apps(IRNative.lessThanInteger, lhs)), rhs), thenArg, elseArg);
+                        modifyTermAndPushToReprocess(current, newTerm);
+                        continue;
+                    }
+                    else if (typeof rhsInt === "bigint") {
+                        const newTerm = _ir_apps(IRNative.strictIfThenElse, _ir_apps(new IRHoisted(_ir_apps(IRNative.lessThanEqualInteger, rhs)), lhs), elseArg, thenArg);
+                        modifyTermAndPushToReprocess(current, newTerm);
+                        continue;
+                    }
+                }
+                else if (isEqualsZero(condFunc)
+                    && condArgs.length === 1) {
+                    const equalZeroArg = condArgs[0];
+                    const equalZeroArgAppTerms = getApplicationTerms(equalZeroArg);
+                    if (!equalZeroArgAppTerms) {
+                        // standard continuation
+                        stack.unshift(...current.children());
+                        continue;
+                    }
+                    const { func: eqZeroArgFunc, args: eqZeroArgArgs } = equalZeroArgAppTerms;
+                    if (isListLength(eqZeroArgFunc)
+                        && eqZeroArgArgs.length === 1) {
+                        const listTerm = eqZeroArgArgs[0];
+                        // replace with isNullList
+                        const newTerm = _ir_apps(IRNative.strictChooseList, listTerm, thenArg, elseArg);
+                        modifyTermAndPushToReprocess(current, newTerm);
+                        continue;
+                    }
+                    // standard continuation
+                    stack.unshift(...current.children());
+                    continue;
+                } // if( x.length() === 0 )
+                else if (isNullList(condFunc)
+                    && condArgs.length === 1) {
+                    const listTerm = condArgs[0];
+                    // replace with isListLength
+                    const newTerm = _ir_apps(IRNative.strictChooseList, listTerm, thenArg, elseArg);
+                    modifyTermAndPushToReprocess(current, newTerm);
+                    continue;
+                } // if( x.isEmpty() )
+            } // strictIfThenElse
+            else if (tag === IRNativeTag.equalsInteger
+                && restArgs.length === 1) {
+                const sndArg = restArgs[0];
+                const fstInt = getConstInt(fstArg);
+                const sndInt = getConstInt(sndArg);
+                if (fstInt === BigInt(0)) {
+                    // replace as `isZero( sndArg )`
+                    const newTerm = _ir_apps(IRNative._isZero, sndArg);
+                    modifyTermAndPushToReprocess(current, newTerm);
+                    continue;
+                }
+                else if (sndInt === BigInt(0)) {
+                    // replace as `isZero( fstArg )`
+                    const newTerm = _ir_apps(IRNative._isZero, fstArg);
+                    modifyTermAndPushToReprocess(current, newTerm);
+                    continue;
+                }
+                else if (typeof fstInt === "bigint" && typeof sndInt === "bigint") {
+                    // replace as constant
+                    const newTerm = IRConst.bool(fstInt === sndInt);
+                    modifyTermAndPushToReprocess(current, newTerm);
+                    continue;
+                }
+                else if (typeof fstInt === "bigint") {
+                    const newTerm = _ir_apps(new IRHoisted(_ir_apps(IRNative.equalsInteger, fstArg)), sndArg);
+                    modifyTermAndPushToReprocess(current, newTerm);
+                    continue;
+                }
+                else if (typeof sndInt === "bigint") {
+                    const newTerm = _ir_apps(new IRHoisted(_ir_apps(IRNative.equalsInteger, sndArg)), fstArg);
+                    modifyTermAndPushToReprocess(current, newTerm);
+                    continue;
+                }
+            } // equalsInteger
+            else if (tag === IRNativeTag.addInteger
+                && restArgs.length === 1) {
+                const sndArg = restArgs[0];
+                const fstInt = getConstInt(fstArg);
+                const sndInt = getConstInt(sndArg);
+                if (fstInt === BigInt(1)) {
+                    // replace as `incr( sndArg )`
+                    const newTerm = _ir_apps(IRNative._increment, sndArg);
+                    modifyTermAndPushToReprocess(current, newTerm);
+                    continue;
+                }
+                else if (sndInt === BigInt(1)) {
+                    // replace as `incr( fstArg )`
+                    const newTerm = _ir_apps(IRNative._increment, fstArg);
+                    modifyTermAndPushToReprocess(current, newTerm);
+                    continue;
+                }
+                else if (typeof fstInt === "bigint" && typeof sndInt === "bigint") {
+                    // replace as constant
+                    const newTerm = IRConst.int(fstInt + sndInt);
+                    modifyTermAndPushToReprocess(current, newTerm);
+                    continue;
+                }
+                else if (typeof fstInt === "bigint") {
+                    const newTerm = _ir_apps(new IRHoisted(_ir_apps(IRNative.addInteger, fstArg)), sndArg);
+                    modifyTermAndPushToReprocess(current, newTerm);
+                    continue;
+                }
+                else if (typeof sndInt === "bigint") {
+                    const newTerm = _ir_apps(new IRHoisted(_ir_apps(IRNative.addInteger, sndArg)), fstArg);
+                    modifyTermAndPushToReprocess(current, newTerm);
+                    continue;
+                }
+            } // addInteger
+            else if (tag === IRNativeTag.subtractInteger
+                && restArgs.length === 1) {
+                const sndArg = restArgs[0];
+                const sndInt = getConstInt(sndArg);
+                if (sndInt === BigInt(1)) {
+                    // replace as `decr( fstArg )`
+                    const newTerm = _ir_apps(IRNative._decrement, fstArg);
+                    modifyTermAndPushToReprocess(current, newTerm);
+                    continue;
+                }
+                else if (typeof sndInt === "bigint") {
+                    const newTerm = _ir_apps(new IRHoisted(_ir_apps(IRNative.addInteger, IRConst.int(-sndInt))), fstArg);
+                    modifyTermAndPushToReprocess(current, newTerm);
+                    continue;
+                }
+            }
+        }
+        // only optimizations if first argument is constant after this point
         if (!(fstArg instanceof IRConst)) {
             stack.unshift(...current.children());
             continue;
@@ -43,14 +237,7 @@ export function rewriteNativesAppliedToConstantsAndReturnRoot(term) {
             && (typeof fstArg.value === "bigint"
                 || typeof fstArg.value === "number")) {
             const newTerm = restArgs.length >= 1 ? _ir_apps(_compTimeDropN(fstArg.value), ...restArgs) : _compTimeDropN(fstArg.value);
-            if (parent) {
-                _modifyChildFromTo(parent, current, newTerm);
-            }
-            else {
-                term = newTerm;
-                term.parent = undefined;
-            }
-            stack.unshift(newTerm);
+            modifyTermAndPushToReprocess(current, newTerm);
             continue;
         }
         // const tsEnsureExhaustiveCheck: never = func;
@@ -83,3 +270,91 @@ function isId(term) {
         && term.body instanceof IRVar
         && term.body.name === term.params[0]));
 }
+function isNot(term) {
+    while (term instanceof IRHoisted
+        || term instanceof IRLetted) {
+        if (term instanceof IRHoisted)
+            term = term.hoisted;
+        else if (term instanceof IRLetted)
+            term = term.value;
+    }
+    return (term instanceof IRNative
+        && term.tag === IRNativeTag._not) || (equalIrHash(hoisted_not.hoisted.hash, term.hash));
+}
+function isNullList(term) {
+    while (term instanceof IRHoisted
+        || term instanceof IRLetted) {
+        if (term instanceof IRHoisted)
+            term = term.hoisted;
+        else if (term instanceof IRLetted)
+            term = term.value;
+    }
+    return (term instanceof IRNative
+        && term.tag === IRNativeTag.nullList);
+}
+function isEqualsZero(term) {
+    while (term instanceof IRHoisted
+        || term instanceof IRLetted) {
+        if (term instanceof IRHoisted)
+            term = term.hoisted;
+        else if (term instanceof IRLetted)
+            term = term.value;
+    }
+    return (term instanceof IRNative
+        && term.tag === IRNativeTag._isZero) || (equalIrHash(hoisted_isZero.hash, term.hash));
+}
+function isLessThanOrEqualInteger(term) {
+    while (term instanceof IRHoisted
+        || term instanceof IRLetted) {
+        if (term instanceof IRHoisted)
+            term = term.hoisted;
+        else if (term instanceof IRLetted)
+            term = term.value;
+    }
+    return (term instanceof IRNative
+        && term.tag === IRNativeTag.lessThanEqualInteger);
+}
+function isLessThanInteger(term) {
+    while (term instanceof IRHoisted
+        || term instanceof IRLetted) {
+        if (term instanceof IRHoisted)
+            term = term.hoisted;
+        else if (term instanceof IRLetted)
+            term = term.value;
+    }
+    return (term instanceof IRNative
+        && term.tag === IRNativeTag.lessThanInteger);
+}
+function isListLength(term) {
+    while (term instanceof IRHoisted
+        || term instanceof IRLetted) {
+        if (term instanceof IRHoisted)
+            term = term.hoisted;
+        else if (term instanceof IRLetted)
+            term = term.value;
+    }
+    return (term instanceof IRNative
+        && term.tag === IRNativeTag._length) || equalIrHash(hoisted_length.hash, term.hash);
+}
+function getConstInt(term) {
+    if (term instanceof IRConst
+        && term.type instanceof TirIntT
+        && typeof term.value === "bigint")
+        return term.value;
+    return undefined;
+}
+// function isConstIntOne( term: IRTerm ): boolean
+// {
+//     return (
+//         term instanceof IRConst
+//         && term.type instanceof TirIntT
+//         && term.value === BigInt( 1 )
+//     );
+// }
+function getConstBool(term) {
+    if (term instanceof IRConst
+        && term.type instanceof TirBoolT
+        && typeof term.value === "boolean")
+        return term.value;
+    return undefined;
+}

package/dist/IR/utils/positiveIntAsBytes.js

@@ -1,5 +1,5 @@
 import { fromHex } from "@harmoniclabs/uint8array-utils";
-import UPLCFlatUtils from "../../utils/UPLCFlatUtils/index.js";
+import { UPLCFlatUtils } from "../../utils/UPLCFlatUtils/index.js";
 /**
  * writes the number in a new `Uint8Array` Big Endian
  */

package/dist/compiler/AstCompiler/AstCompiler.d.ts

@@ -41,6 +41,8 @@ export declare class AstCompiler extends DiagnosticEmitter {
     readonly parsedAstSources: Map<string, Source>;
     get rootPath(): string;
     constructor(cfg: CompilerOptions, io?: CompilerIoApi, diagnostics?: DiagnosticMessage[]);
+    private _isExporting;
+    export(funcName: string, modulePath?: string): Promise<TypedProgram>;
     /**
      * compiles the entry file specified in the config
      *

package/dist/compiler/AstCompiler/AstCompiler.js

@@ -35,6 +35,7 @@ import { _deriveContractBody } from "./internal/_deriveContractBody/_deriveContr
 import { DiagnosticCategory } from "../../diagnostics/DiagnosticCategory.js";
 import { VarStmt } from "../../ast/nodes/statements/VarStmt.js";
 import { _compileSimpleVarDecl } from "./internal/statements/_compileVarStmt.js";
+import { isIdentifier } from "../../utils/text.js";
 /*
 Handling type expressions that depend on other types
 (such as generics, function return types, and inferred types from complex expressions)
@@ -84,6 +85,24 @@ export class AstCompiler extends DiagnosticEmitter {
         this.cfg = cfg;
         this.io = io;
         this.program = new TypedProgram(this.diagnostics);
+        this._isExporting = false;
+    }
+    _isExporting;
+    async export(funcName, modulePath) {
+        this._isExporting = true;
+        if (typeof funcName !== "string")
+            throw new Error("AstCompiler.export: funcName must be a string");
+        funcName = funcName.trim();
+        if (funcName === "" || !isIdentifier(funcName))
+            throw new Error("AstCompiler.export: funcName must be a valid function identifier");
+        if (typeof modulePath === "string") {
+            const nextEntryPath = modulePath;
+            if (!nextEntryPath)
+                throw new Error("AstCompiler.export: modulePath not found: " + modulePath);
+            this.cfg.entry = nextEntryPath;
+        }
+        this.program.contractTirFuncName = funcName;
+        return await this.compile();
     }
     /**
      * compiles the entry file specified in the config
@@ -115,6 +134,7 @@ export class AstCompiler extends DiagnosticEmitter {
         }
         const mainFuncExpr = this.program.functions.get(this.program.contractTirFuncName);
         if (this.program.contractTirFuncName === "" || !mainFuncExpr) {
+            console.log([...this.program.functions.keys()]);
             console.error(mainFuncExpr, `"${this.program.contractTirFuncName}"`);
             this.error(DiagnosticCode.Contract_is_missing, undefined);
             return this.program;
@@ -205,8 +225,11 @@ export class AstCompiler extends DiagnosticEmitter {
             if (exported && stmt instanceof TypeImplementsStmt)
                 this.error(DiagnosticCode.Interface_implementations_cannot_be_exported, exportRange ?? stmt.range);
             if (stmt instanceof ContractDecl) {
+                if (!(
                 // ignore contract declarations if not in the entry file
-                if (!isEntryFile) {
+                isEntryFile
+                    // ignore contract decalarations if we are exporting a specific function
+                    || this._isExporting)) {
                     // remove from array so we don't process it again
                     void stmts.splice(i, 1);
                     i--;
@@ -300,6 +323,9 @@ export class AstCompiler extends DiagnosticEmitter {
         const astFuncExpr = stmt.expr;
         const astFuncName = astFuncExpr.name.text;
         const tirFuncName = PEBBLE_INTERNAL_IDENTIFIER_PREFIX + astFuncName + "_" + srcUid;
+        if (this._isExporting && astFuncName === this.program.contractTirFuncName) {
+            this.program.contractTirFuncName = tirFuncName;
+        }
         const declContext = AstCompilationCtx.fromScope(this.program, topLevelScope);
         const funcExpr = _compileFuncExpr(declContext, astFuncExpr, undefined, // sig
         false // isMethod

package/dist/compiler/AstCompiler/internal/exprs/_compileFuncExpr.js

@@ -74,6 +74,12 @@ export function _compileFuncExpr(ctx, expr, expectedFuncType, isMethod = false)
     }
     const returnType = expectedFuncType.returnType;
     const funcCtx = ctx.newFunctionChildScope(returnType, isMethod);
+    // define value in case of recursion
+    funcCtx.scope.defineValue({
+        name: expr.name.text,
+        type: expectedFuncType,
+        isConstant: true,
+    });
     // if( _hasDuplicateTypeParams( ctx, expr.typeParams ) ) return undefined;
     if (expr.typeParams.length > 0)
         return ctx.error(DiagnosticCode.Not_implemented_0, expr.typeParams[0].range, "generic functions");

package/dist/compiler/Compiler.d.ts

@@ -6,5 +6,12 @@ export declare class Compiler extends DiagnosticEmitter {
     readonly io: CompilerIoApi;
     readonly cfg: CompilerOptions;
     constructor(io?: CompilerIoApi, cfg?: CompilerOptions, diagnostics?: DiagnosticMessage[]);
-    compile(config?: Partial<CompilerOptions>): Promise<void>;
+    compile(config?: Partial<CompilerOptions>): Promise<Uint8Array>;
+    export(config: Partial<ExportOptions> & HasFuncitonName): Promise<Uint8Array>;
 }
+interface HasFuncitonName {
+    functionName: string;
+}
+export interface ExportOptions extends CompilerOptions, HasFuncitonName {
+}
+export {};

package/dist/compiler/Compiler.js

@@ -43,6 +43,39 @@ export class Compiler extends DiagnosticEmitter {
         this.io.writeFile(outPath, serialized, cfg.root);
         this.io.stdout.write(`compiled program written to ${outPath}\n`);
         __VERY_UNSAFE_FORGET_IRHASH_ONLY_USE_AT_END_OF_UPLC_COMPILATION();
-        return;
+        return serialized;
+    }
+    async export(config) {
+        const cfg = {
+            ...this.cfg,
+            ...config,
+            // NEVER generate markers when exporting a function
+            addMarker: false,
+        };
+        if (typeof cfg.functionName !== "string" || cfg.functionName.length === 0) {
+            throw new Error("Compiler::export - invalid function name in export options");
+        }
+        const astCompiler = new AstCompiler(cfg, this.io, this.diagnostics);
+        const program = await astCompiler.export(cfg.functionName, cfg.entry);
+        if (this.diagnostics.length > 0) {
+            let msg;
+            globalThis.console && console.log(this.diagnostics);
+            const fstErrorMsg = this.diagnostics[0].toString();
+            const nDiags = this.diagnostics.length;
+            while (msg = this.diagnostics.shift()) {
+                this.io.stdout.write(msg.toString() + "\n");
+            }
+            throw new Error("compilation failed with " + nDiags + " diagnostic messages; first message: " + fstErrorMsg);
+        }
+        // backend starts here
+        const ir = compileTypedProgram(cfg, program);
+        const uplc = compileIRToUPLC(ir, cfg);
+        const serialized = compileUPLC(new UPLCProgram(cfg.targetUplcVersion, uplc)).toBuffer().buffer;
+        const outDir = cfg.outDir;
+        const outPath = outDir + (outDir.endsWith("/") ? "" : "/") + "out.flat";
+        this.io.writeFile(outPath, serialized, cfg.root);
+        this.io.stdout.write(`compiled program written to ${outPath}\n`);
+        __VERY_UNSAFE_FORGET_IRHASH_ONLY_USE_AT_END_OF_UPLC_COMPILATION();
+        return serialized;
     }
 }

package/dist/compiler/TirCompiler/expressify/ExpressifyCtx.js

@@ -119,7 +119,7 @@ export class ExpressifyCtx {
         const result = (this._getNonHoistedVariable(name)
             ?? this.hoisted.get(name));
         if (!result) {
-            console.log(this.allVariables());
+            console.log("[error log]: allVariables", this.allVariables());
             throw new Error(`variable '${name}' not found in the context`);
         }
         return result;

package/dist/compiler/TirCompiler/expressify/expressify.js

@@ -41,6 +41,8 @@ import { TirCallExpr } from "../../tir/expressions/TirCallExpr.js";
 import { TirNativeFunc } from "../../tir/expressions/TirNativeFunc.js";
 export function expressify(func, loopReplacements, program, parentCtx = undefined) {
     const ctx = new ExpressifyCtx(parentCtx, func.returnType, program);
+    // define in case of recursion
+    ctx.setFuncParam(func.name, func.type);
     ctx.introduceFuncParams(func.params);
     func.body.stmts = [
         new TirReturnStmt(expressifyFuncBody(ctx, func.body.stmts, loopReplacements), func.body.range)

package/dist/compiler/TirCompiler/expressify/expressifyVars.js

@@ -384,7 +384,7 @@ function expressifyMethodCall(ctx, methodCall) {
     throw new Error(`Cannot call method '${methodName}' on non-struct type '${objectType.toString()}'`);
 }
 function expressifyListMethodCall(ctx, objectExpr, methodCall, methodName, listType, exprRange) {
-    const elemsType = getListTypeArg(listType);
+    const elemsType = getUnaliased(getListTypeArg(listType));
     if (!elemsType)
         throw new Error("Invalid list type");
     if (methodName === "length") {
@@ -432,22 +432,46 @@ function expressifyListMethodCall(ctx, objectExpr, methodCall, methodName, listT
         // console.log( finalType );
         return new TirCallExpr(TirNativeFunc._findSopOptional(elemsType), [methodCall.args[0], objectExpr], methodCall.type, exprRange);
     }
+    if (methodName === "filter") {
+        if (methodCall.args.length !== 1)
+            throw new Error(`Method 'filter' of type 'list' takes 1 argument, ${methodCall.args.length} provided`);
+        return new TirCallExpr(TirNativeFunc._filter(elemsType), [methodCall.args[0], objectExpr], methodCall.type, exprRange);
+    }
+    if (methodName === "prepend") {
+        if (methodCall.args.length !== 1)
+            throw new Error(`Method 'prepend' of type 'list' takes 1 argument, ${methodCall.args.length} provided`);
+        return new TirCallExpr(TirNativeFunc.mkCons(elemsType), [methodCall.args[0], objectExpr], methodCall.type, exprRange);
+    }
+    if (methodName === "map") {
+        if (methodCall.args.length !== 1)
+            throw new Error(`Method 'map' of type 'list' takes 1 argument, ${methodCall.args.length} provided`);
+        const arg = methodCall.args[0];
+        const argFuncType = getUnaliased(arg.type);
+        if (!(argFuncType instanceof TirFuncT))
+            throw new Error(`Argument 1 of method 'map' of type 'list' must be a function, got '${arg.type.toString()}'`);
+        const mapReturnT = argFuncType.returnType;
+        const elemTypeTirName = elemsType.toTirTypeKey();
+        let base_mapToType = _base_mapToType_cache.get(elemTypeTirName)?.clone();
+        if (!base_mapToType) {
+            base_mapToType = new TirHoistedExpr("_map_to_list_of_" + elemTypeTirName, new TirCallExpr(TirNativeFunc._mkMap(elemsType, mapReturnT), [new TirLitArrExpr([], new TirListT(mapReturnT), SourceRange.unknown)], new TirFuncT([
+                // mapping function
+                new TirFuncT([
+                    elemsType
+                ], mapReturnT),
+                // list to map over
+                new TirListT(elemsType)
+            ], new TirListT(mapReturnT)), SourceRange.unknown));
+            base_mapToType.varName; // precompute hash and symbol
+            _base_mapToType_cache.set(elemTypeTirName, base_mapToType.clone());
+        }
+        return new TirCallExpr(base_mapToType, [methodCall.args[0], objectExpr], methodCall.type, exprRange);
+    }
     // TODO
     /*
     {
-        isEmpty: new TirFuncT( [], bool_t ),
         show: new TirFuncT( [], bytes_t ),
         reverse: new TirFuncT( [], new TirListT( elemsType ) ),
-        find: new TirFuncT([
-            new TirFuncT( [elemsType], bool_t )
-        ], new TirSopOptT( elemsType ) ),
-        filter: new TirFuncT([
-            new TirFuncT( [elemsType], bool_t )
-        ], new TirListT( elemsType ) ),
-        prepend: new TirFuncT( [elemsType], new TirListT( elemsType ) ),
-        map: new TirFuncT([
-            new TirFuncT([ elemsType ], mapReturnT )
-        ], new TirListT( mapReturnT ) ),
     };
     */
 }
+const _base_mapToType_cache = new Map();

package/dist/compiler/tir/expressions/TirNativeFunc.d.ts

@@ -84,12 +84,12 @@ export declare class TirNativeFunc implements ITirExpr {
     static _dropList(elemT: TirType): TirNativeFunc;
     static _foldr(elemT: TirType, returnT: TirType): TirNativeFunc;
     static _foldl(elemT: TirType, returnT: TirType): TirNativeFunc;
-    static _mkFindDataOptional(elems_t: TirType): TirNativeFunc;
     static _findSopOptional(elems_t: TirType): TirNativeFunc;
     static _length(elemT: TirType): TirNativeFunc;
     static _some(elemT: TirType): TirNativeFunc;
     static _every(elemT: TirType): TirNativeFunc;
-    static _mkFilter(elemT: TirType): TirNativeFunc;
+    static _filter(elemT: TirType): TirNativeFunc;
+    static _mkMap(elemT: TirType, returnElemT: TirType): TirNativeFunc;
     static _id(t: TirType): TirNativeFunc;
     static get _not(): TirNativeFunc;
     static get _strictAnd(): TirNativeFunc;

package/dist/compiler/tir/expressions/TirNativeFunc.js

@@ -663,16 +663,19 @@ export class TirNativeFunc {
             new TirListT(elemT)
         ], returnT));
     }
-    static _mkFindDataOptional(elems_t) {
-        return new TirNativeFunc(IRNativeTag._mkFindDataOptional, new TirFuncT([
-            // elem -> data
-            new TirFuncT([elems_t], data_t),
-            // elem -> bool (predicate)
-            new TirFuncT([elems_t], bool_t),
-            // List<elem>
-            new TirListT(elems_t)
-        ], new TirDataOptT(elems_t)));
-    }
+    // static _mkFindDataOptional(elems_t: TirType): TirNativeFunc {
+    //     return new TirNativeFunc(
+    //         IRNativeTag._mkFindDataOptional,
+    //         new TirFuncT([
+    //             // elem -> data
+    //             new TirFuncT([ elems_t ], data_t),
+    //             // elem -> bool (predicate)
+    //             new TirFuncT([ elems_t ], bool_t),
+    //             // List<elem>
+    //             new TirListT(elems_t)
+    //         ], new TirDataOptT(elems_t))
+    //     );
+    // }
     static _findSopOptional(elems_t) {
         return new TirNativeFunc(IRNativeTag._findSopOptional, new TirFuncT([
             // predicate: (elemT) => bool
@@ -705,10 +708,8 @@ export class TirNativeFunc {
             new TirListT(elemT)
         ], bool_t));
     }
-    static _mkFilter(elemT) {
-        return new TirNativeFunc(IRNativeTag._mkFilter, new TirFuncT([
-            // pnilOfType: an empty list with the right element type
-            new TirListT(elemT),
+    static _filter(elemT) {
+        return new TirNativeFunc(IRNativeTag._filter, new TirFuncT([
             // predicate
             new TirFuncT([
                 elemT
@@ -717,6 +718,18 @@ export class TirNativeFunc {
             new TirListT(elemT)
         ], new TirListT(elemT)));
     }
+    static _mkMap(elemT, returnElemT) {
+        return new TirNativeFunc(IRNativeTag._mkMapList, new TirFuncT([
+            // nil of return elem type
+            new TirListT(returnElemT),
+            // mapping function
+            new TirFuncT([
+                elemT
+            ], returnElemT),
+            // list to map over
+            new TirListT(elemT)
+        ], new TirListT(returnElemT)));
+    }
     static _id(t) {
         return new TirNativeFunc(IRNativeTag._id, new TirFuncT([t], t));
     }

package/dist/utils/BitUtils/index.d.ts

@@ -1,7 +1,7 @@
 /**
  * @static
  */
-export default class BitUtils {
+export declare class BitUtils {
     private constructor();
     /**
      * @deprecated not sure it has ever made sense to have it

package/dist/utils/BitUtils/index.js

@@ -1,7 +1,7 @@
 /**
  * @static
  */
-export default class BitUtils {
+export class BitUtils {
     constructor() { }
     /**
      * @deprecated not sure it has ever made sense to have it

package/dist/utils/IsSingleKey.d.ts

@@ -3,5 +3,5 @@ type SingleKeyObj<K extends string | number | symbol, V = any> = {
         [Q in keyof O]: O[Q];
     } : never;
 }[K];
-export default SingleKeyObj;
 export type IsSingleKey<Obj extends object> = Obj extends SingleKeyObj<keyof Obj> ? true : false;
+export {};

package/dist/utils/UPLCFlatUtils/index.d.ts

@@ -8,7 +8,7 @@ export interface BitStreamPadToByteOptions {
 /**
  * @static
  */
-export default class UPLCFlatUtils {
+export declare class UPLCFlatUtils {
     /**
      * @deprecated this is a @static class, it is not supposed to have instances
      */

package/dist/utils/UPLCFlatUtils/index.js

@@ -1,6 +1,6 @@
 import { BitStream } from "@harmoniclabs/bitstream";
-import BitUtils from "../BitUtils/index.js";
 import { assert } from "../assert.js";
+import { BitUtils } from "../BitUtils/index.js";
 export function isInByteOffset(offset) {
     return (offset === 0 ||
         offset === 1 ||
@@ -14,7 +14,7 @@ export function isInByteOffset(offset) {
 /**
  * @static
  */
-export default class UPLCFlatUtils {
+export class UPLCFlatUtils {
     /**
      * @deprecated this is a @static class, it is not supposed to have instances
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@harmoniclabs/pebble",
-  "version": "0.1.0-dev7",
+  "version": "0.1.0-dev8",
   "description": "A simple, yet rock solid, functional language with an imperative bias, targeting UPLC",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -52,14 +52,14 @@
   "dependencies": {
     "@harmoniclabs/bigint-utils": "^1.0.0",
     "@harmoniclabs/bytestring": "^1.0.0",
-    "@harmoniclabs/cbor": "^1.6.0",
-    "@harmoniclabs/crypto": "^0.2.5",
+    "@harmoniclabs/cbor": "^1.6.6",
+    "@harmoniclabs/crypto": "^0.3.0",
     "@harmoniclabs/obj-utils": "^1.0.0",
     "@harmoniclabs/pair": "^1.0.0",
-    "@harmoniclabs/plutus-data": "^1.2.4",
-    "@harmoniclabs/plutus-machine": "^2.1.0",
+    "@harmoniclabs/plutus-data": "^1.2.6",
+    "@harmoniclabs/plutus-machine": "^2.1.1",
     "@harmoniclabs/uint8array-utils": "^1.0.4",
-    "@harmoniclabs/uplc": "^1.4.0"
+    "@harmoniclabs/uplc": "^1.4.1"
   },
   "devDependencies": {
     "@babel/preset-env": "^7.18.6",