functionalscript 0.3.4 → 0.3.6

package/nanvm-lib/src/interface.rs

@@ -1,133 +0,0 @@
-use core::fmt;
-
-use crate::{nullish::Nullish, sign::Sign, simple::Simple};
-
-pub trait Container: Clone {
-    type Header;
-    type Item;
-    fn header(&self) -> &Self::Header;
-    /// For now, we use a slice.
-    /// We may change it in the future to support more sophisticated containers.
-    fn items(&self) -> &[Self::Item];
-    fn new(header: Self::Header, items: impl IntoIterator<Item = Self::Item>) -> Self;
-}
-
-pub trait Complex<U: Any>: PartialEq + Sized + Container {
-    fn to_unknown(self) -> U;
-    fn try_from_unknown(u: U) -> Result<Self, U>;
-}
-
-pub trait String16<U: Any<String16 = Self>>:
-    Complex<U> + Container<Header = (), Item = u16>
-{
-}
-
-pub trait BigInt<U: Any<BigInt = Self>>: Complex<U> + Container<Header = Sign, Item = u64> {}
-
-pub trait Array<U: Any<Array = Self>>: Complex<U> + Container<Header = (), Item = U> {}
-
-pub trait Object<U: Any<Object = Self>>:
-    Complex<U> + Container<Header = (), Item = (U::String16, U)>
-{
-}
-
-pub trait Function<U: Any<Function = Self>>:
-    Complex<U> + Container<Header = u32, Item = u8>
-{
-}
-
-pub trait Any: PartialEq + Sized + Clone + fmt::Debug {
-    type String16: String16<Self>;
-    type BigInt: BigInt<Self>;
-    type Array: Array<Self>;
-    type Object: Object<Self>;
-    type Function: Function<Self>;
-
-    fn pack(u: Unpacked<Self>) -> Self;
-    fn unpack(self) -> Unpacked<Self>;
-
-    fn new_simple(value: Simple) -> Self;
-    fn try_to_simple(&self) -> Option<Simple>;
-
-    fn try_to<C: Complex<Self>>(self) -> Result<C, Self> {
-        C::try_from_unknown(self)
-    }
-
-    fn to_string(self) -> Self::String16 {
-        if let Some(simple) = self.try_to_simple() {
-            return simple.to_string::<Self>();
-        }
-        if let Ok(v) = self.clone().try_to::<Self::String16>() {
-            return v;
-        }
-        if self.clone().try_to::<Self::Array>().is_ok() {
-            return "".to_string16::<Self>();
-        }
-        if self.clone().try_to::<Self::Object>().is_ok() {
-            return "[object Object]".to_string16::<Self>();
-        }
-        // bigint and function
-        todo!()
-    }
-}
-
-#[derive(PartialEq, Debug, Clone)]
-pub enum Unpacked<U: Any> {
-    Nullish(Nullish),
-    Bool(bool),
-    Number(f64),
-    String16(U::String16),
-    BigInt(U::BigInt),
-    Array(U::Array),
-    Object(U::Object),
-    Function(U::Function),
-}
-
-pub trait Extension: Sized {
-    fn to_complex<C: Complex<impl Any> + Container<Header = ()>>(self) -> C
-    where
-        Self: IntoIterator<Item = C::Item>,
-    {
-        C::new((), self)
-    }
-
-    fn to_string16_unknown<U: Any>(self) -> U
-    where
-        Self: IntoIterator<Item = u16>,
-    {
-        self.to_complex::<U::String16>().to_unknown()
-    }
-
-    fn to_array_unknown(self) -> Self::Item
-    where
-        Self: IntoIterator<Item: Any>,
-    {
-        self.to_complex::<<Self::Item as Any>::Array>().to_unknown()
-    }
-
-    fn to_object_unknown<U: Any>(self) -> U
-    where
-        Self: IntoIterator<Item = (U::String16, U)>,
-    {
-        self.to_complex::<U::Object>().to_unknown()
-    }
-}
-
-impl<T> Extension for T {}
-
-// Utf8
-
-pub trait Utf8 {
-    fn to_string16<U: Any>(&self) -> U::String16;
-    fn to_unknown<U: Any>(&self) -> U;
-}
-
-impl Utf8 for str {
-    fn to_string16<U: Any>(&self) -> U::String16 {
-        self.encode_utf16().to_complex()
-    }
-
-    fn to_unknown<U: Any>(&self) -> U {
-        self.to_string16::<U>().to_unknown()
-    }
-}

package/nanvm-lib/src/lib.rs

@@ -1,7 +0,0 @@
-pub mod extension;
-pub mod interface;
-pub mod naive;
-pub mod nanenum;
-pub mod nullish;
-pub mod sign;
-pub mod simple;

package/nanvm-lib/src/naive.rs

@@ -1,236 +0,0 @@
-use core::{fmt, marker::PhantomData};
-use std::rc;
-
-use crate::{
-    interface::{self},
-    sign::Sign,
-    simple::Simple,
-};
-
-pub trait Policy {
-    type Header: PartialEq + fmt::Debug + Clone;
-    type Item: fmt::Debug;
-    fn items_eq(a: &[Self::Item], b: &[Self::Item]) -> bool;
-}
-
-#[derive(Clone)]
-pub struct ValuePolicy<H, T>(PhantomData<(H, T)>);
-
-impl<H: PartialEq + fmt::Debug + Clone, T: PartialEq + fmt::Debug> Policy for ValuePolicy<H, T> {
-    type Header = H;
-    type Item = T;
-    fn items_eq(a: &[Self::Item], b: &[Self::Item]) -> bool {
-        a == b
-    }
-}
-
-#[derive(Clone)]
-pub struct RefPolicy<H, T>(PhantomData<(H, T)>);
-
-impl<H: PartialEq + fmt::Debug + Clone, T: fmt::Debug> Policy for RefPolicy<H, T> {
-    type Header = H;
-    type Item = T;
-    fn items_eq(a: &[Self::Item], b: &[Self::Item]) -> bool {
-        a.as_ptr() == b.as_ptr()
-    }
-}
-
-pub struct Complex<P: Policy> {
-    header: P::Header,
-    items: rc::Rc<[P::Item]>,
-}
-
-impl<P: Policy> Clone for Complex<P> {
-    fn clone(&self) -> Self {
-        Self {
-            header: self.header.clone(),
-            items: self.items.clone(),
-        }
-    }
-}
-
-impl<P: Policy> fmt::Debug for Complex<P> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("Complex")
-            .field("header", &self.header)
-            .field("items", &self.items)
-            .finish()
-    }
-}
-
-impl<P: Policy> PartialEq for Complex<P> {
-    fn eq(&self, other: &Self) -> bool {
-        self.header == other.header && P::items_eq(&self.items, &other.items)
-    }
-}
-
-impl<P: Policy> interface::Container for Complex<P> {
-    type Header = P::Header;
-    type Item = P::Item;
-    fn items(&self) -> &[Self::Item] {
-        &self.items
-    }
-    fn header(&self) -> &Self::Header {
-        &self.header
-    }
-    fn new(header: Self::Header, items: impl IntoIterator<Item = Self::Item>) -> Self {
-        Self {
-            header,
-            items: rc::Rc::from_iter(items),
-        }
-    }
-}
-
-// String
-
-pub type String16 = Complex<ValuePolicy<(), u16>>;
-
-impl interface::Complex<Any> for String16 {
-    fn to_unknown(self) -> Any {
-        Any::String16(self)
-    }
-    fn try_from_unknown(u: Any) -> Result<Self, Any> {
-        if let Any::String16(v) = u {
-            Ok(v)
-        } else {
-            Err(u)
-        }
-    }
-}
-
-impl interface::String16<Any> for String16 {}
-
-// BigInt
-
-pub type BigInt = Complex<ValuePolicy<Sign, u64>>;
-
-impl interface::Complex<Any> for BigInt {
-    fn to_unknown(self) -> Any {
-        Any::BigInt(self)
-    }
-    fn try_from_unknown(u: Any) -> Result<Self, Any> {
-        if let Any::BigInt(v) = u {
-            Ok(v)
-        } else {
-            Err(u)
-        }
-    }
-}
-
-impl interface::BigInt<Any> for BigInt {}
-
-// Array
-
-pub type Array = Complex<RefPolicy<(), Any>>;
-
-impl interface::Complex<Any> for Array {
-    fn to_unknown(self) -> Any {
-        Any::Array(self)
-    }
-    fn try_from_unknown(u: Any) -> Result<Self, Any> {
-        if let Any::Array(v) = u {
-            Ok(v)
-        } else {
-            Err(u)
-        }
-    }
-}
-
-impl interface::Array<Any> for Array {}
-
-// Object
-
-pub type Object = Complex<RefPolicy<(), (String16, Any)>>;
-
-impl interface::Complex<Any> for Object {
-    fn to_unknown(self) -> Any {
-        Any::Object(self)
-    }
-    fn try_from_unknown(u: Any) -> Result<Self, Any> {
-        if let Any::Object(v) = u {
-            Ok(v)
-        } else {
-            Err(u)
-        }
-    }
-}
-
-impl interface::Object<Any> for Object {}
-
-// Function
-
-pub type Function = Complex<RefPolicy<u32, u8>>;
-
-impl interface::Complex<Any> for Function {
-    fn to_unknown(self) -> Any {
-        Any::Function(self)
-    }
-
-    fn try_from_unknown(u: Any) -> Result<Self, Any> {
-        if let Any::Function(v) = u {
-            Ok(v)
-        } else {
-            Err(u)
-        }
-    }
-}
-
-impl interface::Function<Any> for Function {}
-
-// Unknown
-
-#[derive(PartialEq, Debug, Clone)]
-pub enum Any {
-    Simple(Simple),
-    String16(String16),
-    BigInt(BigInt),
-    Array(Array),
-    Object(Object),
-    Function(Function),
-}
-
-impl interface::Any for Any {
-    type String16 = String16;
-    type BigInt = BigInt;
-    type Array = Array;
-    type Object = Object;
-    type Function = Function;
-
-    fn new_simple(value: Simple) -> Self {
-        Self::Simple(value)
-    }
-
-    fn try_to_simple(&self) -> Option<Simple> {
-        if let Self::Simple(v) = self {
-            Some(v.clone())
-        } else {
-            None
-        }
-    }
-
-    fn pack(u: interface::Unpacked<Self>) -> Self {
-        match u {
-            interface::Unpacked::Nullish(n) => Self::Simple(Simple::Nullish(n)),
-            interface::Unpacked::Bool(n) => Self::Simple(Simple::Boolean(n)),
-            interface::Unpacked::Number(n) => Self::Simple(Simple::Number(n)),
-            interface::Unpacked::String16(n) => Self::String16(n),
-            interface::Unpacked::BigInt(n) => Self::BigInt(n),
-            interface::Unpacked::Array(n) => Self::Array(n),
-            interface::Unpacked::Object(n) => Self::Object(n),
-            interface::Unpacked::Function(n) => Self::Function(n),
-        }
-    }
-
-    fn unpack(self) -> interface::Unpacked<Self> {
-        match self {
-            Any::Simple(Simple::Nullish(n)) => interface::Unpacked::Nullish(n),
-            Any::Simple(Simple::Boolean(n)) => interface::Unpacked::Bool(n),
-            Any::Simple(Simple::Number(n)) => interface::Unpacked::Number(n),
-            Any::String16(complex) => interface::Unpacked::String16(complex),
-            Any::BigInt(complex) => interface::Unpacked::BigInt(complex),
-            Any::Array(complex) => interface::Unpacked::Array(complex),
-            Any::Object(complex) => interface::Unpacked::Object(complex),
-            Any::Function(complex) => interface::Unpacked::Function(complex),
-        }
-    }
-}

package/nanvm-lib/src/nanenum.rs

@@ -1,236 +0,0 @@
-use core::{marker::PhantomData, mem::forget};
-use std::rc::Rc;
-
-trait Raw64: Clone {
-    /// Number of bits in the packed structure.
-    const BIT_SIZE: u64;
-    /// Moving ownership from `v` to `Self`.`
-    unsafe fn from_raw64(v: u64) -> Self;
-    /// Moving ownership from `self` to `u64`.
-    unsafe fn into_raw64(self) -> u64;
-}
-
-impl<T> Raw64 for Rc<T> {
-    const BIT_SIZE: u64 = 48;
-    unsafe fn from_raw64(v: u64) -> Self {
-        Rc::from_raw(v as _)
-    }
-    unsafe fn into_raw64(self) -> u64 {
-        Rc::into_raw(self) as *const _ as _
-    }
-}
-
-#[derive(Clone)]
-enum NaNEnum<T: Raw64> {
-    Number(f64),
-    Else(T),
-}
-
-const NEGATIVE: u64 = 1 << 63;
-
-const NOT_FINITE: u64 = 0b0111_1111_1111_0000 << 48;
-
-const INFINITY: u64 = NOT_FINITE;
-
-const NEG_INFINITY: u64 = INFINITY | NEGATIVE;
-
-const NAN: u64 = NOT_FINITE | (1 << 51);
-
-const ELSE: u64 = NAN | NEGATIVE;
-
-const ELSE_DATA: u64 = (1 << 51) - 1;
-
-//  INFINITY: 7FF0...
-// -INFINITY: FFF0...
-//  NAN     : 7FF8...
-//  ELSE    : FFF8...
-//  NUMBER  : ...
-
-/// Represents packed implementation of `NaNEnum`.
-///
-/// Note: currently, only `2^51` values are allowed for `Else`.
-///       However, there are `2^53 - 3` are available,
-///       so it's possible to use more than 51 bits in the future.
-struct NaNEnumPack<T: Raw64>(u64, PhantomData<T>);
-
-impl<T: Raw64> NaNEnumPack<T> {
-    fn check(&self, mask: u64) -> bool {
-        self.0 & mask == mask
-    }
-    /// Creates a temporary object that should be `forget` after using.
-    unsafe fn tmp_unpack(&self) -> NaNEnum<T> {
-        if self.check(ELSE) {
-            NaNEnum::Else(T::from_raw64(self.0 & ELSE_DATA))
-        } else {
-            NaNEnum::Number(f64::from_bits(self.0))
-        }
-    }
-    fn unpack(self) -> NaNEnum<T> {
-        let result = unsafe { self.tmp_unpack() };
-        forget(self);
-        result
-    }
-    fn pack(v: NaNEnum<T>) -> Self {
-        assert!(T::BIT_SIZE <= 51);
-        Self(
-            match v {
-                NaNEnum::Number(n) => n.to_bits(),
-                NaNEnum::Else(e) => unsafe { e.into_raw64() | ELSE },
-            },
-            PhantomData,
-        )
-    }
-}
-
-impl<T: Raw64> Clone for NaNEnumPack<T> {
-    fn clone(&self) -> Self {
-        let tmp = unsafe { self.tmp_unpack() };
-        let c = tmp.clone();
-        forget(tmp);
-        Self::pack(c)
-    }
-}
-
-impl<T: Raw64> Drop for NaNEnumPack<T> {
-    fn drop(&mut self) {
-        unsafe { self.tmp_unpack() };
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use core::{
-        mem::forget,
-        ptr::null,
-        sync::atomic::{AtomicUsize, Ordering},
-    };
-    use std::rc::Rc;
-
-    use crate::nanenum::{Raw64, NEGATIVE, NOT_FINITE};
-
-    use super::{NaNEnum, NaNEnumPack};
-
-    // See https://doc.rust-lang.org/std/mem/fn.needs_drop.html
-
-    /*
-    trait Dropable {
-        const _A: () = assert!(needs_drop::<Self>());
-    }
-
-    trait NonDropable {
-        const _A: () = assert!(!needs_drop::<Self>());
-    }
-    */
-
-    #[test]
-    fn test_f64() {
-        assert_eq!(f64::INFINITY.to_bits(), NOT_FINITE);
-        assert_eq!((f64::NEG_INFINITY).to_bits(), NOT_FINITE | NEGATIVE);
-        assert_eq!(f64::NAN.to_bits(), NOT_FINITE | (1 << 51));
-    }
-
-    #[test]
-    fn test_pack() {
-        static I: AtomicUsize = AtomicUsize::new(0);
-
-        struct P();
-
-        impl Default for P {
-            fn default() -> Self {
-                I.fetch_add(1, Ordering::Relaxed);
-                Self()
-            }
-        }
-
-        impl Clone for P {
-            fn clone(&self) -> Self {
-                Self::default()
-            }
-        }
-
-        impl Drop for P {
-            fn drop(&mut self) {
-                I.fetch_sub(1, Ordering::Relaxed);
-            }
-        }
-
-        impl Raw64 for P {
-            const BIT_SIZE: u64 = 0;
-            unsafe fn from_raw64(v: u64) -> Self {
-                Self()
-            }
-            unsafe fn into_raw64(self) -> u64 {
-                forget(self);
-                0
-            }
-        }
-
-        //
-
-        {
-            assert_eq!(I.load(Ordering::Relaxed), 0);
-            {
-                let x = P::default();
-                assert_eq!(I.load(Ordering::Relaxed), 1);
-                let m = NaNEnum::Else(x);
-                assert_eq!(I.load(Ordering::Relaxed), 1);
-                let p = NaNEnumPack::pack(m);
-                assert_eq!(I.load(Ordering::Relaxed), 1);
-                let p1 = p.clone();
-                assert_eq!(I.load(Ordering::Relaxed), 2);
-                let m1 = p1.unpack();
-                assert_eq!(I.load(Ordering::Relaxed), 2);
-                if let NaNEnum::Else(x1) = m1 {
-                    assert_eq!(I.load(Ordering::Relaxed), 2);
-                    // assert_ne!(&x as *const _, null())
-                    // assert_ne!(&m as *const _, null())
-                    assert_ne!(&p as *const _, null());
-                    // assert_ne!(&p1 as *const _, null());
-                    // assert_ne!(&m1 as *const _, null());
-                    assert_ne!(&x1 as *const _, null());
-                } else {
-                    panic!()
-                }
-            }
-            assert_eq!(I.load(Ordering::Relaxed), 0);
-        }
-
-        //
-
-        {
-            assert_eq!(I.load(Ordering::Relaxed), 0);
-            {
-                let x = P::default();
-                assert_eq!(I.load(Ordering::Relaxed), 1);
-                let m = NaNEnum::Else(x.clone());
-                assert_eq!(I.load(Ordering::Relaxed), 2);
-                let p = NaNEnumPack::pack(m.clone());
-                assert_eq!(I.load(Ordering::Relaxed), 3);
-                let p1 = p.clone();
-                assert_eq!(I.load(Ordering::Relaxed), 4);
-                let m1 = p1.clone().unpack();
-                assert_eq!(I.load(Ordering::Relaxed), 5);
-                if let NaNEnum::Else(x1) = m1.clone() {
-                    assert_eq!(I.load(Ordering::Relaxed), 6);
-                    assert_ne!(&x as *const _, null());
-                    assert_ne!(&m as *const _, null());
-                    assert_ne!(&p as *const _, null());
-                    assert_ne!(&p1 as *const _, null());
-                    assert_ne!(&m1 as *const _, null());
-                    assert_ne!(&x1 as *const _, null());
-                } else {
-                    panic!()
-                }
-            }
-            assert_eq!(I.load(Ordering::Relaxed), 0);
-        }
-    }
-
-    #[test]
-    fn test_ptr() {
-        let x = Rc::new("hello");
-        let m = NaNEnum::Else(x);
-        let p = NaNEnumPack::pack(m);
-        let p1 = p.clone();
-    }
-}

package/nanvm-lib/src/nullish.rs

@@ -1,7 +0,0 @@
-/// https://developer.mozilla.org/en-US/docs/Glossary/Nullish
-/// "In JavaScript, a nullish value is the value which is either null or undefined. Nullish values are always falsy."
-#[derive(Debug, PartialEq, Clone, Copy)]
-pub enum Nullish {
-    Null,
-    Undefined,
-}

package/nanvm-lib/src/sign.rs

@@ -1,5 +0,0 @@
-#[derive(PartialEq, Debug, Clone)]
-pub enum Sign {
-    Positive = 1,
-    Negative = -1,
-}

package/nanvm-lib/src/simple.rs

@@ -1,32 +0,0 @@
-use crate::{
-    interface::{Any, Utf8},
-    nullish::Nullish,
-};
-
-#[derive(PartialEq, Debug, Clone)]
-pub enum Simple {
-    Nullish(Nullish),
-    Boolean(bool),
-    Number(f64),
-}
-
-impl Simple {
-    pub fn to_unknown<U: Any>(self) -> U {
-        U::new_simple(self)
-    }
-    pub fn to_string<U: Any>(self) -> U::String16 {
-        match self {
-            Simple::Nullish(v) => (match v {
-                Nullish::Null => "null",
-                Nullish::Undefined => "undefined",
-            })
-            .to_string16::<U>(),
-            Simple::Boolean(v) => (match v {
-                true => "true",
-                false => "false",
-            })
-            .to_string16::<U>(),
-            Simple::Number(_) => todo!(),
-        }
-    }
-}