/*---------------------------------------------------------------------------
  Copyright 2012-2025, Microsoft Research, Daan Leijen.

  This is free software; you can redistribute it and/or modify it under the
  terms of the Apache License, Version 2.0. A copy of the License can be
  found in the LICENSE file at the root of this distribution.
---------------------------------------------------------------------------*/

// Internal functions to support lazy constructors
//
module std/core/lazystd/core/lazy

import std/core/typesstd/core/types

extern import 
  js file "inline/lazy.js"

// note: all of the following definitions will be made hidden (prefix with `@`)
// in the future and are only exposed for now for experimentation

// internal: marker for lazy values that will be memoized (used to for correct reuse and reference counting)
pub inline fip extern memoize-targetstd/core/lazy/memoize-target: forall<a> (target : a, size : int, scan-size : int) -> ()(^target : aa: V, size : intstd/core/types/int: V, scan-size : intstd/core/types/int: V) : (std/core/types/unit: V)std/core/types/unit: V
  c  inline "/**/"      // optimized away
  js inline "null"

// internal: explicitly force update-in-place for lazy values
pub fip extern memoizestd/core/lazy/memoize: forall<a> (target : a, x : a) -> a(targettarget: $40 : aa: V, xx: $40 : aa: V) : astd/core/types/total: E
  c inline "#1"         // optimized away during codegen (reuse analysis)
  js "kk_lazy_memoize"  // todo: optimize this as part of codegen

// internal: atomically set a lazy value to locked (or return `false` if already memoized)
pub inline fip extern atomic-enterstd/core/lazy/atomic-enter: forall<a> (target : a, indirect-tag : int32) -> bool(^target : aa: V, indirect-tag: int32std/core/types/int32: V ) : boolstd/core/types/bool: V
  c  "kk_lazy_atomic_enter"
  js "$std_core_lazy.kk_lazy_atomic_enter"

// internal: release an atomically memoized lazy value
pub inline fip extern atomic-leavestd/core/lazy/atomic-leave: forall<a> (target : a) -> ()(target : aa: V) : (std/core/types/unit: V)std/core/types/unit: V
  c  "kk_lazy_atomic_leave"
  js "$std_core_lazy.kk_lazy_atomic_leave"


// internal: test if a lazy value is in whnf
pub inline fip extern datatype-is-whnfstd/core/lazy/datatype-is-whnf: forall<a> (x : a, indirect-tag : int32) -> bool(^x:aa: V, indirect-tag:int32std/core/types/int32: V) : boolstd/core/types/bool: V
  c "kk_datatype_is_whnf"
  js inline "(#1._tag < #2)"

// internal: test if a heap allocated lazy value is in whnf
pub inline fip extern datatype-ptr-is-whnfstd/core/lazy/datatype-ptr-is-whnf: forall<a> (x : a, indirect-tag : int32) -> bool(^x:aa: V, indirect-tag:int32std/core/types/int32: V) : boolstd/core/types/bool: V
  c  "kk_datatype_ptr_is_whnf"
  js inline "(#1._tag < #2)"


// internal: test if a heap allocated data type is unique
pub inline fip extern datatype-ptr-is-uniquestd/core/lazy/datatype-ptr-is-unique: forall<a> (x : a) -> bool(^x:aa: V) : boolstd/core/types/bool: V
  c "kk_datatype_ptr_is_unique"
  js inline "false"

// internal: test if a heap allocated data type is thread-shared
pub inline fip extern datatype-ptr-is-thread-sharedstd/core/lazy/datatype-ptr-is-thread-shared: forall<a> (x : a) -> bool(^x : aa: V) : boolstd/core/types/bool: V
  c "kk_datatype_ptr_is_thread_shared"
  js inline "false"


// internal: compress indirection chains
pub inline fip extern indirect-compressstd/core/lazy/indirect-compress: forall<a> (value : a, indirect-tag : int32) -> a(value : aa: V, indirect-tag:int32std/core/types/int32: V) : astd/core/types/total: E
  c  "kk_indirect_compress"
  js "$std_core_lazy.kk_indirect_compres"

val internalstd/core/lazy/internal: int = 42literal: int
dec  = 42
hex8 = 0x2A
bit8 = 0b00101010