From 7572047084b14b2652fabc6fd4d59d2b42bc5bd1 Mon Sep 17 00:00:00 2001 From: Jordan Martinez Date: Wed, 5 Jul 2023 07:49:12 -0500 Subject: [PATCH 1/3] Update FFI to uncurried functions --- bower.json | 3 +- src/Node/Buffer/Immutable.js | 95 +++++++--------------------------- src/Node/Buffer/Immutable.purs | 43 ++++++++------- src/Node/Buffer/Internal.js | 77 +++++---------------------- src/Node/Buffer/Internal.purs | 86 ++++++++++++++++++------------ src/Node/Encoding.js | 9 ++-- src/Node/Encoding.purs | 6 ++- 7 files changed, 118 insertions(+), 201 deletions(-) diff --git a/bower.json b/bower.json index 0d182ef..840fb17 100644 --- a/bower.json +++ b/bower.json @@ -17,7 +17,8 @@ "purescript-effect": "^4.0.0", "purescript-maybe": "^6.0.0", "purescript-st": "^6.0.0", - "purescript-unsafe-coerce": "^6.0.0" + "purescript-unsafe-coerce": "^6.0.0", + "purescript-nullable": "^6.0.0" }, "devDependencies": { "purescript-assert": "^6.0.0", diff --git a/src/Node/Buffer/Immutable.js b/src/Node/Buffer/Immutable.js index 48517b7..4dd1c00 100644 --- a/src/Node/Buffer/Immutable.js +++ b/src/Node/Buffer/Immutable.js @@ -1,99 +1,40 @@ -/* global Buffer */ +import { Buffer } from "node:buffer"; + import { inspect } from "util"; export const showImpl = inspect; -export function eqImpl(a) { - return b => { - return a.equals(b); - }; -} +export const eqImpl = (a, b) => a.equals(b); -export function compareImpl(a) { - return b => { - return a.compare(b); - }; -} +export const compareImpl = (a, b) => a.compare(b); -export function create(size) { - return Buffer.alloc(size); -} +export const create = (size) => Buffer.alloc(size); -export function fromArray(octets) { - return Buffer.from(octets); -} +export const fromArray = (octets) => Buffer.from(octets); -export function size(buff) { - return buff.length; -} +export const size = (buff) => buff.length; export function toArray(buff) { var json = buff.toJSON(); return json.data || json; } -export function toArrayBuffer(buff) { - return buff.buffer.slice(buff.byteOffset, buff.byteOffset + buff.byteLength); -} +export const toArrayBuffer = (buff) => + buff.buffer.slice(buff.byteOffset, buff.byteOffset + buff.byteLength); -export function fromArrayBuffer(ab) { - return Buffer.from(ab); -} +export const fromArrayBuffer = (ab) => Buffer.from(ab); -export function fromStringImpl(str) { - return encoding => { - return Buffer.from(str, encoding); - }; -} +export const fromStringImpl = (str, encoding) => Buffer.from(str, encoding); -export function readImpl(ty) { - return offset => { - return buf => { - return buf["read" + ty](offset); - }; - }; -} +export const readImpl = (ty, offset, buf) => buf["read" + ty](offset); -export function readStringImpl(enc) { - return start => { - return end => { - return buff => { - return buff.toString(enc, start, end); - }; - }; - }; -} +export const readStringImpl = (enc, start, end, buff) => buff.toString(enc, start, end); -export function getAtOffsetImpl(just) { - return nothing => { - return offset => { - return buff => { - var octet = buff[offset]; - return octet == null ? nothing : just(octet); - }; - }; - }; -} +export const getAtOffsetImpl = (offset, buff) => buff[offset]; -export function toStringImpl(enc) { - return buff => { - return buff.toString(enc); - }; -} +export const toStringImpl = (enc, buff) => buff.toString(enc); -export function slice(start) { - return end => { - return buff => { - return buff.slice(start, end); - }; - }; -} +export const sliceImpl = (start, end, buff) => buff.slice(start, end); -export function concat(buffs) { - return Buffer.concat(buffs); -} +export const concat = (buffs) => Buffer.concat(buffs); -export function concatToLength(buffs) { - return totalLength => { - return Buffer.concat(buffs, totalLength); - }; -} +export const concatToLength = (buffs, totalLength) => Buffer.concat(buffs, totalLength); diff --git a/src/Node/Buffer/Immutable.purs b/src/Node/Buffer/Immutable.purs index 9d5d731..285c32c 100644 --- a/src/Node/Buffer/Immutable.purs +++ b/src/Node/Buffer/Immutable.purs @@ -20,7 +20,9 @@ module Node.Buffer.Immutable import Prelude import Data.ArrayBuffer.Types (ArrayBuffer) -import Data.Maybe (Maybe(..)) +import Data.Function.Uncurried (Fn2, Fn3, Fn4, runFn2, runFn3, runFn4) +import Data.Maybe (Maybe) +import Data.Nullable (Nullable, toMaybe) import Node.Buffer.Types (BufferValueType, Octet, Offset) import Node.Encoding (Encoding, encodingToNode) @@ -33,18 +35,18 @@ instance showBuffer :: Show ImmutableBuffer where foreign import showImpl :: ImmutableBuffer -> String instance eqBuffer :: Eq ImmutableBuffer where - eq = eqImpl + eq a b = runFn2 eqImpl a b -foreign import eqImpl :: ImmutableBuffer -> ImmutableBuffer -> Boolean +foreign import eqImpl :: Fn2 ImmutableBuffer ImmutableBuffer Boolean instance ordBuffer :: Ord ImmutableBuffer where compare a b = - case compareImpl a b of + case runFn2 compareImpl a b of x | x < 0 -> LT x | x > 0 -> GT _ -> EQ -foreign import compareImpl :: ImmutableBuffer -> ImmutableBuffer -> Int +foreign import compareImpl :: Fn2 ImmutableBuffer ImmutableBuffer Int -- | Creates a new buffer of the specified size. foreign import create :: Int -> ImmutableBuffer @@ -59,28 +61,27 @@ foreign import fromArrayBuffer :: ArrayBuffer -> ImmutableBuffer -- | Creates a new buffer from a string with the specified encoding, sized to match the string. fromString :: String -> Encoding -> ImmutableBuffer -fromString str = fromStringImpl str <<< encodingToNode +fromString str = runFn2 fromStringImpl str <<< encodingToNode -foreign import fromStringImpl :: String -> String -> ImmutableBuffer +foreign import fromStringImpl :: Fn2 String String ImmutableBuffer -- | Reads a numeric value from a buffer at the specified offset. read :: BufferValueType -> Offset -> ImmutableBuffer -> Number -read = readImpl <<< show +read ty off buf = runFn3 readImpl (show ty) off buf -foreign import readImpl :: String -> Offset -> ImmutableBuffer -> Number +foreign import readImpl :: Fn3 String Offset ImmutableBuffer Number -- | Reads a section of a buffer as a string with the specified encoding. readString :: Encoding -> Offset -> Offset -> ImmutableBuffer -> String -readString = readStringImpl <<< encodingToNode +readString enc start end buf = runFn4 readStringImpl (encodingToNode enc) start end buf -foreign import readStringImpl - :: String -> Offset -> Offset -> ImmutableBuffer -> String +foreign import readStringImpl :: Fn4 String Offset Offset ImmutableBuffer String -- | Reads the buffer as a string with the specified encoding. toString :: Encoding -> ImmutableBuffer -> String -toString = toStringImpl <<< encodingToNode +toString enc buf = runFn2 toStringImpl (encodingToNode enc) buf -foreign import toStringImpl :: String -> ImmutableBuffer -> String +foreign import toStringImpl :: Fn2 String ImmutableBuffer String -- | Creates an array of octets from a buffer's contents. foreign import toArray :: ImmutableBuffer -> Array Octet @@ -90,10 +91,9 @@ foreign import toArrayBuffer :: ImmutableBuffer -> ArrayBuffer -- | Reads an octet from a buffer at the specified offset. getAtOffset :: Offset -> ImmutableBuffer -> Maybe Octet -getAtOffset = getAtOffsetImpl Just Nothing +getAtOffset off buf = toMaybe $ runFn2 getAtOffsetImpl off buf -foreign import getAtOffsetImpl - :: (Octet -> Maybe Octet) -> Maybe Octet -> Offset -> ImmutableBuffer -> Maybe Octet +foreign import getAtOffsetImpl :: Fn2 Offset ImmutableBuffer (Nullable Octet) -- | Concatenates a list of buffers. foreign import concat :: Array ImmutableBuffer -> ImmutableBuffer @@ -101,12 +101,15 @@ foreign import concat :: Array ImmutableBuffer -> ImmutableBuffer -- | Concatenates a list of buffers, combining them into a new buffer of the -- | specified length. concat' :: Array ImmutableBuffer -> Int -> ImmutableBuffer -concat' = concatToLength +concat' a i = runFn2 concatToLength a i -foreign import concatToLength :: Array ImmutableBuffer -> Int -> ImmutableBuffer +foreign import concatToLength :: Fn2 (Array ImmutableBuffer) Int ImmutableBuffer -- | Creates a new buffer slice that shares the memory of the original buffer. -foreign import slice :: Offset -> Offset -> ImmutableBuffer -> ImmutableBuffer +slice :: Offset -> Offset -> ImmutableBuffer -> ImmutableBuffer +slice start end buf = runFn3 sliceImpl start end buf + +foreign import sliceImpl :: Fn3 Offset Offset ImmutableBuffer ImmutableBuffer -- | Returns the size of a buffer. foreign import size :: ImmutableBuffer -> Int diff --git a/src/Node/Buffer/Internal.js b/src/Node/Buffer/Internal.js index 2af2886..8061884 100644 --- a/src/Node/Buffer/Internal.js +++ b/src/Node/Buffer/Internal.js @@ -1,68 +1,19 @@ -/* global Buffer */ -export function copyAll(a) { - return () => { - return Buffer.from(a); - }; -} +import { Buffer } from "node:buffer"; -export function writeInternal(ty) { - return value => { - return offset => { - return buf => { - return () => { - buf["write" + ty](value, offset); - }; - }; - }; - }; -} +export const freezeImpl = (a) => Buffer.from(a); +export const thawImpl = (a) => Buffer.from(a); -export function writeStringInternal(encoding) { - return offset => { - return length => { - return value => { - return buff => { - return () => { - return buff.write(value, offset, length, encoding); - }; - }; - }; - }; - }; -} +export const writeInternal = (ty, value, offset, buf) => buf["write" + ty](value, offset); -export function setAtOffset(value) { - return offset => { - return buff => { - return () => { - buff[offset] = value; - }; - }; - }; -} +export const writeStringInternal = (encoding, offset, length, value, buff) => + buff.write(value, offset, length, encoding); -export function copy(srcStart) { - return srcEnd => { - return src => { - return targStart => { - return targ => { - return () => { - return src.copy(targ, targStart, srcStart, srcEnd); - }; - }; - }; - }; - }; -} +export const setAtOffsetImpl = (value, offset, buff) => { + buff[offset] = value; +}; -export function fill(octet) { - return start => { - return end => { - return buf => { - return () => { - buf.fill(octet, start, end); - }; - }; - }; - }; -} +export const copyImpl = (srcStart, srcEnd, src, targStart, targ) => + src.copy(targ, targStart, srcStart, srcEnd); + +export const fillImpl = (octet, start, end, buf) => + buf.fill(octet, start, end); diff --git a/src/Node/Buffer/Internal.purs b/src/Node/Buffer/Internal.purs index 94b40ff..acceb21 100644 --- a/src/Node/Buffer/Internal.purs +++ b/src/Node/Buffer/Internal.purs @@ -5,7 +5,8 @@ module Node.Buffer.Internal , usingFromImmutable , usingToImmutable , create - , copyAll + , freeze + , thaw , fromArray , fromString , fromArrayBuffer @@ -30,81 +31,102 @@ import Prelude import Data.ArrayBuffer.Types (ArrayBuffer) import Data.Maybe (Maybe) +import Effect.Uncurried (EffectFn1, EffectFn3, EffectFn4, EffectFn5, runEffectFn1, runEffectFn3, runEffectFn4, runEffectFn5) +import Node.Buffer.Class (freeze, thaw) import Node.Buffer.Immutable (ImmutableBuffer) import Node.Buffer.Immutable as Immutable import Node.Buffer.Types (BufferValueType, Octet, Offset) import Node.Encoding (Encoding, encodingToNode) import Unsafe.Coerce (unsafeCoerce) -unsafeFreeze :: forall buf m. Monad m => buf -> m ImmutableBuffer +unsafeFreeze :: Buffer -> Effect ImmutableBuffer unsafeFreeze = pure <<< unsafeCoerce -unsafeThaw :: forall buf m. Monad m => ImmutableBuffer -> m buf +unsafeThaw :: ImmutableBuffer -> Effect Buffer unsafeThaw = pure <<< unsafeCoerce -usingFromImmutable :: forall buf m a. Monad m => (ImmutableBuffer -> a) -> buf -> m a +usingFromImmutable :: forall a. (ImmutableBuffer -> a) -> Buffer -> Effect a usingFromImmutable f buf = f <$> unsafeFreeze buf -usingToImmutable :: forall buf m a. Monad m => (a -> ImmutableBuffer) -> a -> m buf +usingToImmutable :: forall a. (a -> ImmutableBuffer) -> a -> Effect Buffer usingToImmutable f x = unsafeThaw $ f x -create :: forall buf m. Monad m => Int -> m buf +create :: Int -> Effect Buffer create = usingToImmutable Immutable.create -foreign import copyAll :: forall a buf m. a -> m buf +freeze :: Buffer -> Effect ImmutableBuffer +freeze = runEffectFn1 freezeImpl -fromArray :: forall buf m. Monad m => Array Octet -> m buf +foreign import freezeImpl :: EffectFn1 Buffer ImmutableBuffer + +thaw :: ImmutableBuffer -> Effect Buffer +thaw = runEffectFn1 thawImpl + +foreign import thawImpl :: EffectFn1 ImmutableBuffer Buffer + +fromArray :: Array Octet -> Effect Buffer fromArray = usingToImmutable Immutable.fromArray -fromString :: forall buf m. Monad m => String -> Encoding -> m buf +fromString :: String -> Encoding -> Effect Buffer fromString s = usingToImmutable $ Immutable.fromString s -fromArrayBuffer :: forall buf m. Monad m => ArrayBuffer -> m buf +fromArrayBuffer :: ArrayBuffer -> Effect Buffer fromArrayBuffer = usingToImmutable Immutable.fromArrayBuffer -toArrayBuffer :: forall buf m. Monad m => buf -> m ArrayBuffer +toArrayBuffer :: Buffer -> Effect ArrayBuffer toArrayBuffer = usingFromImmutable Immutable.toArrayBuffer -read :: forall buf m. Monad m => BufferValueType -> Offset -> buf -> m Number +read :: BufferValueType -> Offset -> Buffer -> Effect Number read t o = usingFromImmutable $ Immutable.read t o -readString :: forall buf m. Monad m => Encoding -> Offset -> Offset -> buf -> m String -readString m o o' = usingFromImmutable $ Immutable.readString m o o' +readString :: Encoding -> Offset -> Offset -> Buffer -> Effect String +readString enc o o' = usingFromImmutable $ Immutable.readString enc o o' -toString :: forall buf m. Monad m => Encoding -> buf -> m String -toString m = usingFromImmutable $ Immutable.toString m +toString :: Encoding -> Buffer -> Effect String +toString enc = usingFromImmutable $ Immutable.toString enc -write :: forall buf m. Monad m => BufferValueType -> Number -> Offset -> buf -> m Unit -write = writeInternal <<< show +write :: BufferValueType -> Number -> Offset -> Buffer -> Effect Unit +write ty value offset buf = runEffectFn4 writeInternal (show ty) value offset buf -foreign import writeInternal :: forall buf m. String -> Number -> Offset -> buf -> m Unit +foreign import writeInternal :: EffectFn4 String Number Offset Buffer Unit -writeString :: forall buf m. Monad m => Encoding -> Offset -> Int -> String -> buf -> m Int -writeString = writeStringInternal <<< encodingToNode +writeString :: Encoding -> Offset -> Int -> String -> Buffer -> Effect Int +writeString enc offset len value buf = + runEffectFn5 writeStringInternal (encodingToNode enc) offset len value buf -foreign import writeStringInternal - :: forall buf m. String -> Offset -> Int -> String -> buf -> m Int +foreign import writeStringInternal :: EffectFn5 String Offset Int String Buffer Int -toArray :: forall buf m. Monad m => buf -> m (Array Octet) +toArray :: Buffer -> Effect (Array Octet) toArray = usingFromImmutable Immutable.toArray -getAtOffset :: forall buf m. Monad m => Offset -> buf -> m (Maybe Octet) +getAtOffset :: Offset -> Buffer -> Effect (Maybe Octet) getAtOffset o = usingFromImmutable $ Immutable.getAtOffset o -foreign import setAtOffset :: forall buf m. Octet -> Offset -> buf -> m Unit +setAtOffset :: Octet -> Offset -> Buffer -> Effect Unit +setAtOffset val off buff = runEffectFn3 setAtOffsetImpl val off buff -slice :: forall buf. Offset -> Offset -> buf -> buf +foreign import setAtOffsetImpl :: EffectFn3 Octet Offset Buffer Unit + +slice :: Offset -> Offset -> Buffer -> Buffer slice = unsafeCoerce Immutable.slice -size :: forall buf m. Monad m => buf -> m Int +size :: Buffer -> Effect Int size = usingFromImmutable Immutable.size -concat :: forall buf m. Array buf -> m buf +concat :: Array Buffer -> Effect Buffer concat arrs = unsafeCoerce \_ -> Immutable.concat (unsafeCoerce arrs) -concat' :: forall buf m. Monad m => Array buf -> Int -> m buf +concat' :: Array Buffer -> Int -> Effect Buffer concat' arrs n = unsafeCoerce \_ -> Immutable.concat' (unsafeCoerce arrs) n -foreign import copy :: forall buf m. Offset -> Offset -> buf -> Offset -> buf -> m Int +copy :: Offset -> Offset -> Buffer -> Offset -> Buffer -> Effect Int +copy srcStart srcEnd src targStart targ = do + runEffectFn5 copyImpl srcStart srcEnd src targStart targ + +foreign import copyImpl :: EffectFn5 Offset Offset Buffer Offset Buffer Int + +fill :: Octet -> Offset -> Offset -> Buffer -> Effect Unit +fill octet start end buf = do + runEffectFn4 fillImpl octet start end buf -foreign import fill :: forall buf m. Octet -> Offset -> Offset -> buf -> m Unit +foreign import fillImpl :: EffectFn4 Octet Offset Offset Buffer Unit diff --git a/src/Node/Encoding.js b/src/Node/Encoding.js index 608e31d..dcfecb9 100644 --- a/src/Node/Encoding.js +++ b/src/Node/Encoding.js @@ -1,6 +1,3 @@ -/* global Buffer */ -export function byteLengthImpl(str) { - return enc => { - return Buffer.byteLength(str, enc); - }; -} +import { Buffer } from "node:buffer"; + +export const byteLengthImpl = (str, enc) => Buffer.byteLength(str, enc); diff --git a/src/Node/Encoding.purs b/src/Node/Encoding.purs index 86c53c5..97ec62e 100644 --- a/src/Node/Encoding.purs +++ b/src/Node/Encoding.purs @@ -6,6 +6,8 @@ module Node.Encoding import Prelude +import Data.Function.Uncurried (Fn2, runFn2) + data Encoding = ASCII | UTF8 @@ -38,7 +40,7 @@ encodingToNode Latin1 = "latin1" encodingToNode Binary = "binary" encodingToNode Hex = "hex" -foreign import byteLengthImpl :: String -> String -> Int +foreign import byteLengthImpl :: Fn2 String String Int byteLength :: String -> Encoding -> Int -byteLength str enc = byteLengthImpl str (encodingToNode enc) +byteLength str enc = runFn2 byteLengthImpl str (encodingToNode enc) From 53e1033d7924a279aca2f23b11acd073a2ccfb33 Mon Sep 17 00:00:00 2001 From: Jordan Martinez Date: Wed, 5 Jul 2023 07:49:33 -0500 Subject: [PATCH 2/3] Inline Internal into Buffer; rewrap ST --- src/Node/{Buffer/Internal.js => Buffer.js} | 0 src/Node/Buffer.purs | 103 ++++++++++------ src/Node/Buffer/Internal.purs | 132 --------------------- src/Node/Buffer/ST.purs | 49 ++++---- 4 files changed, 89 insertions(+), 195 deletions(-) rename src/Node/{Buffer/Internal.js => Buffer.js} (100%) delete mode 100644 src/Node/Buffer/Internal.purs diff --git a/src/Node/Buffer/Internal.js b/src/Node/Buffer.js similarity index 100% rename from src/Node/Buffer/Internal.js rename to src/Node/Buffer.js diff --git a/src/Node/Buffer.purs b/src/Node/Buffer.purs index dcff4e0..a6fe78f 100644 --- a/src/Node/Buffer.purs +++ b/src/Node/Buffer.purs @@ -32,12 +32,14 @@ import Prelude import Data.ArrayBuffer.Types (ArrayBuffer) import Data.Maybe (Maybe) import Effect (Effect) +import Effect.Uncurried (EffectFn1, EffectFn3, EffectFn4, EffectFn5, runEffectFn1, runEffectFn3, runEffectFn4, runEffectFn5) import Node.Buffer.Class (class MutableBuffer) import Node.Buffer.Immutable (ImmutableBuffer) -import Node.Buffer.Internal as Internal +import Node.Buffer.Immutable as Immutable import Node.Buffer.Types (BufferValueType(..), Octet, Offset) as TypesExports -import Node.Buffer.Types (BufferValueType) -import Node.Encoding (Encoding) +import Node.Buffer.Types (BufferValueType, Octet, Offset) +import Node.Encoding (Encoding, encodingToNode) +import Unsafe.Coerce (unsafeCoerce) -- | A reference to a mutable buffer for use with `Effect` foreign import data Buffer :: Type @@ -67,71 +69,94 @@ instance mutableBufferEffect :: MutableBuffer Buffer Effect where copy = copy fill = fill +unsafeFreeze :: Buffer -> Effect ImmutableBuffer +unsafeFreeze = pure <<< unsafeCoerce + +unsafeThaw :: ImmutableBuffer -> Effect Buffer +unsafeThaw = pure <<< unsafeCoerce + +usingFromImmutable :: forall a. (ImmutableBuffer -> a) -> Buffer -> Effect a +usingFromImmutable f buf = f <$> unsafeFreeze buf + +usingToImmutable :: forall a. (a -> ImmutableBuffer) -> a -> Effect Buffer +usingToImmutable f x = unsafeThaw $ f x + create :: Int -> Effect Buffer -create = Internal.create +create = usingToImmutable Immutable.create freeze :: Buffer -> Effect ImmutableBuffer -freeze = Internal.copyAll +freeze = runEffectFn1 freezeImpl -unsafeFreeze :: Buffer -> Effect ImmutableBuffer -unsafeFreeze = Internal.unsafeFreeze +foreign import freezeImpl :: EffectFn1 Buffer ImmutableBuffer thaw :: ImmutableBuffer -> Effect Buffer -thaw = Internal.copyAll +thaw = runEffectFn1 thawImpl -unsafeThaw :: ImmutableBuffer -> Effect Buffer -unsafeThaw = Internal.unsafeThaw +foreign import thawImpl :: EffectFn1 ImmutableBuffer Buffer -fromArray :: Array Int -> Effect Buffer -fromArray = Internal.fromArray +fromArray :: Array Octet -> Effect Buffer +fromArray = usingToImmutable Immutable.fromArray fromString :: String -> Encoding -> Effect Buffer -fromString = Internal.fromString +fromString s = usingToImmutable $ Immutable.fromString s fromArrayBuffer :: ArrayBuffer -> Effect Buffer -fromArrayBuffer = Internal.fromArrayBuffer +fromArrayBuffer = usingToImmutable Immutable.fromArrayBuffer toArrayBuffer :: Buffer -> Effect ArrayBuffer -toArrayBuffer = Internal.toArrayBuffer +toArrayBuffer = usingFromImmutable Immutable.toArrayBuffer -read :: BufferValueType -> Int -> Buffer -> Effect Number -read = Internal.read +read :: BufferValueType -> Offset -> Buffer -> Effect Number +read t o = usingFromImmutable $ Immutable.read t o -readString :: Encoding -> Int -> Int -> Buffer -> Effect String -readString = Internal.readString +readString :: Encoding -> Offset -> Offset -> Buffer -> Effect String +readString enc o o' = usingFromImmutable $ Immutable.readString enc o o' toString :: Encoding -> Buffer -> Effect String -toString = Internal.toString +toString enc = usingFromImmutable $ Immutable.toString enc + +write :: BufferValueType -> Number -> Offset -> Buffer -> Effect Unit +write ty value offset buf = runEffectFn4 writeInternal (show ty) value offset buf + +foreign import writeInternal :: EffectFn4 String Number Offset Buffer Unit -write :: BufferValueType -> Number -> Int -> Buffer -> Effect Unit -write = Internal.write +writeString :: Encoding -> Offset -> Int -> String -> Buffer -> Effect Int +writeString enc offset len value buf = + runEffectFn5 writeStringInternal (encodingToNode enc) offset len value buf -writeString :: Encoding -> Int -> Int -> String -> Buffer -> Effect Int -writeString = Internal.writeString +foreign import writeStringInternal :: EffectFn5 String Offset Int String Buffer Int -toArray :: Buffer -> Effect (Array Int) -toArray = Internal.toArray +toArray :: Buffer -> Effect (Array Octet) +toArray = usingFromImmutable Immutable.toArray -getAtOffset :: Int -> Buffer -> Effect (Maybe Int) -getAtOffset = Internal.getAtOffset +getAtOffset :: Offset -> Buffer -> Effect (Maybe Octet) +getAtOffset o = usingFromImmutable $ Immutable.getAtOffset o -setAtOffset :: Int -> Int -> Buffer -> Effect Unit -setAtOffset = Internal.setAtOffset +setAtOffset :: Octet -> Offset -> Buffer -> Effect Unit +setAtOffset val off buff = runEffectFn3 setAtOffsetImpl val off buff -slice :: Int -> Int -> Buffer -> Buffer -slice = Internal.slice +foreign import setAtOffsetImpl :: EffectFn3 Octet Offset Buffer Unit + +slice :: Offset -> Offset -> Buffer -> Buffer +slice = unsafeCoerce Immutable.slice size :: Buffer -> Effect Int -size = Internal.size +size = usingFromImmutable Immutable.size concat :: Array Buffer -> Effect Buffer -concat = Internal.concat +concat arrs = unsafeCoerce \_ -> Immutable.concat (unsafeCoerce arrs) concat' :: Array Buffer -> Int -> Effect Buffer -concat' = Internal.concat' +concat' arrs n = unsafeCoerce \_ -> Immutable.concat' (unsafeCoerce arrs) n + +copy :: Offset -> Offset -> Buffer -> Offset -> Buffer -> Effect Int +copy srcStart srcEnd src targStart targ = do + runEffectFn5 copyImpl srcStart srcEnd src targStart targ + +foreign import copyImpl :: EffectFn5 Offset Offset Buffer Offset Buffer Int -copy :: Int -> Int -> Buffer -> Int -> Buffer -> Effect Int -copy = Internal.copy +fill :: Octet -> Offset -> Offset -> Buffer -> Effect Unit +fill octet start end buf = do + runEffectFn4 fillImpl octet start end buf -fill :: Int -> Int -> Int -> Buffer -> Effect Unit -fill = Internal.fill +foreign import fillImpl :: EffectFn4 Octet Offset Offset Buffer Unit diff --git a/src/Node/Buffer/Internal.purs b/src/Node/Buffer/Internal.purs deleted file mode 100644 index acceb21..0000000 --- a/src/Node/Buffer/Internal.purs +++ /dev/null @@ -1,132 +0,0 @@ --- | Functions and types to support the other modules. Not for public use. -module Node.Buffer.Internal - ( unsafeFreeze - , unsafeThaw - , usingFromImmutable - , usingToImmutable - , create - , freeze - , thaw - , fromArray - , fromString - , fromArrayBuffer - , toArrayBuffer - , read - , readString - , toString - , write - , writeString - , toArray - , getAtOffset - , setAtOffset - , slice - , size - , concat - , concat' - , copy - , fill - ) where - -import Prelude - -import Data.ArrayBuffer.Types (ArrayBuffer) -import Data.Maybe (Maybe) -import Effect.Uncurried (EffectFn1, EffectFn3, EffectFn4, EffectFn5, runEffectFn1, runEffectFn3, runEffectFn4, runEffectFn5) -import Node.Buffer.Class (freeze, thaw) -import Node.Buffer.Immutable (ImmutableBuffer) -import Node.Buffer.Immutable as Immutable -import Node.Buffer.Types (BufferValueType, Octet, Offset) -import Node.Encoding (Encoding, encodingToNode) -import Unsafe.Coerce (unsafeCoerce) - -unsafeFreeze :: Buffer -> Effect ImmutableBuffer -unsafeFreeze = pure <<< unsafeCoerce - -unsafeThaw :: ImmutableBuffer -> Effect Buffer -unsafeThaw = pure <<< unsafeCoerce - -usingFromImmutable :: forall a. (ImmutableBuffer -> a) -> Buffer -> Effect a -usingFromImmutable f buf = f <$> unsafeFreeze buf - -usingToImmutable :: forall a. (a -> ImmutableBuffer) -> a -> Effect Buffer -usingToImmutable f x = unsafeThaw $ f x - -create :: Int -> Effect Buffer -create = usingToImmutable Immutable.create - -freeze :: Buffer -> Effect ImmutableBuffer -freeze = runEffectFn1 freezeImpl - -foreign import freezeImpl :: EffectFn1 Buffer ImmutableBuffer - -thaw :: ImmutableBuffer -> Effect Buffer -thaw = runEffectFn1 thawImpl - -foreign import thawImpl :: EffectFn1 ImmutableBuffer Buffer - -fromArray :: Array Octet -> Effect Buffer -fromArray = usingToImmutable Immutable.fromArray - -fromString :: String -> Encoding -> Effect Buffer -fromString s = usingToImmutable $ Immutable.fromString s - -fromArrayBuffer :: ArrayBuffer -> Effect Buffer -fromArrayBuffer = usingToImmutable Immutable.fromArrayBuffer - -toArrayBuffer :: Buffer -> Effect ArrayBuffer -toArrayBuffer = usingFromImmutable Immutable.toArrayBuffer - -read :: BufferValueType -> Offset -> Buffer -> Effect Number -read t o = usingFromImmutable $ Immutable.read t o - -readString :: Encoding -> Offset -> Offset -> Buffer -> Effect String -readString enc o o' = usingFromImmutable $ Immutable.readString enc o o' - -toString :: Encoding -> Buffer -> Effect String -toString enc = usingFromImmutable $ Immutable.toString enc - -write :: BufferValueType -> Number -> Offset -> Buffer -> Effect Unit -write ty value offset buf = runEffectFn4 writeInternal (show ty) value offset buf - -foreign import writeInternal :: EffectFn4 String Number Offset Buffer Unit - -writeString :: Encoding -> Offset -> Int -> String -> Buffer -> Effect Int -writeString enc offset len value buf = - runEffectFn5 writeStringInternal (encodingToNode enc) offset len value buf - -foreign import writeStringInternal :: EffectFn5 String Offset Int String Buffer Int - -toArray :: Buffer -> Effect (Array Octet) -toArray = usingFromImmutable Immutable.toArray - -getAtOffset :: Offset -> Buffer -> Effect (Maybe Octet) -getAtOffset o = usingFromImmutable $ Immutable.getAtOffset o - -setAtOffset :: Octet -> Offset -> Buffer -> Effect Unit -setAtOffset val off buff = runEffectFn3 setAtOffsetImpl val off buff - -foreign import setAtOffsetImpl :: EffectFn3 Octet Offset Buffer Unit - -slice :: Offset -> Offset -> Buffer -> Buffer -slice = unsafeCoerce Immutable.slice - -size :: Buffer -> Effect Int -size = usingFromImmutable Immutable.size - -concat :: Array Buffer -> Effect Buffer -concat arrs = unsafeCoerce \_ -> Immutable.concat (unsafeCoerce arrs) - -concat' :: Array Buffer -> Int -> Effect Buffer -concat' arrs n = unsafeCoerce \_ -> Immutable.concat' (unsafeCoerce arrs) n - -copy :: Offset -> Offset -> Buffer -> Offset -> Buffer -> Effect Int -copy srcStart srcEnd src targStart targ = do - runEffectFn5 copyImpl srcStart srcEnd src targStart targ - -foreign import copyImpl :: EffectFn5 Offset Offset Buffer Offset Buffer Int - -fill :: Octet -> Offset -> Offset -> Buffer -> Effect Unit -fill octet start end buf = do - runEffectFn4 fillImpl octet start end buf - -foreign import fillImpl :: EffectFn4 Octet Offset Offset Buffer Unit diff --git a/src/Node/Buffer/ST.purs b/src/Node/Buffer/ST.purs index 40d3e2f..80e1d9d 100644 --- a/src/Node/Buffer/ST.purs +++ b/src/Node/Buffer/ST.purs @@ -33,10 +33,11 @@ import Control.Monad.ST as ST import Data.ArrayBuffer.Types (ArrayBuffer) import Data.Maybe (Maybe) import Node.Buffer (BufferValueType) +import Node.Buffer as Buffer import Node.Buffer.Class (class MutableBuffer) import Node.Buffer.Immutable (ImmutableBuffer) -import Node.Buffer.Internal as Internal import Node.Encoding (Encoding) +import Unsafe.Coerce (unsafeCoerce) -- | A reference to a mutable buffer for use with `ST` -- | @@ -74,70 +75,70 @@ instance mutableBufferST :: MutableBuffer (STBuffer h) (ST h) where fill = fill create :: forall h. Int -> ST h (STBuffer h) -create = Internal.create +create = unsafeCoerce Buffer.create freeze :: forall h. STBuffer h -> ST h ImmutableBuffer -freeze = Internal.copyAll +freeze = unsafeCoerce Buffer.freeze unsafeFreeze :: forall h. STBuffer h -> ST h ImmutableBuffer -unsafeFreeze = Internal.unsafeFreeze +unsafeFreeze = unsafeCoerce Buffer.unsafeFreeze thaw :: forall h. ImmutableBuffer -> ST h (STBuffer h) -thaw = Internal.copyAll +thaw = unsafeCoerce Buffer.thaw unsafeThaw :: forall h. ImmutableBuffer -> ST h (STBuffer h) -unsafeThaw = Internal.unsafeThaw +unsafeThaw = unsafeCoerce Buffer.unsafeThaw fromArray :: forall h. Array Int -> ST h (STBuffer h) -fromArray = Internal.fromArray +fromArray = unsafeCoerce Buffer.fromArray fromString :: forall h. String -> Encoding -> ST h (STBuffer h) -fromString = Internal.fromString +fromString = unsafeCoerce Buffer.fromString fromArrayBuffer :: forall h. ArrayBuffer -> ST h (STBuffer h) -fromArrayBuffer = Internal.fromArrayBuffer +fromArrayBuffer = unsafeCoerce Buffer.fromArrayBuffer toArrayBuffer :: forall h. STBuffer h -> ST h ArrayBuffer -toArrayBuffer = Internal.toArrayBuffer +toArrayBuffer = unsafeCoerce Buffer.toArrayBuffer read :: forall h. BufferValueType -> Int -> STBuffer h -> ST h Number -read = Internal.read +read = unsafeCoerce Buffer.read readString :: forall h. Encoding -> Int -> Int -> STBuffer h -> ST h String -readString = Internal.readString +readString = unsafeCoerce Buffer.readString toString :: forall h. Encoding -> STBuffer h -> ST h String -toString = Internal.toString +toString = unsafeCoerce Buffer.toString write :: forall h. BufferValueType -> Number -> Int -> STBuffer h -> ST h Unit -write = Internal.write +write = unsafeCoerce Buffer.write writeString :: forall h. Encoding -> Int -> Int -> String -> STBuffer h -> ST h Int -writeString = Internal.writeString +writeString = unsafeCoerce Buffer.writeString toArray :: forall h. STBuffer h -> ST h (Array Int) -toArray = Internal.toArray +toArray = unsafeCoerce Buffer.toArray getAtOffset :: forall h. Int -> STBuffer h -> ST h (Maybe Int) -getAtOffset = Internal.getAtOffset +getAtOffset = unsafeCoerce Buffer.getAtOffset setAtOffset :: forall h. Int -> Int -> STBuffer h -> ST h Unit -setAtOffset = Internal.setAtOffset +setAtOffset = unsafeCoerce Buffer.setAtOffset slice :: forall h. Int -> Int -> STBuffer h -> STBuffer h -slice = Internal.slice +slice = unsafeCoerce Buffer.slice size :: forall h. STBuffer h -> ST h Int -size = Internal.size +size = unsafeCoerce Buffer.size concat :: forall h. Array (STBuffer h) -> ST h (STBuffer h) -concat = Internal.concat +concat = unsafeCoerce Buffer.concat concat' :: forall h. Array (STBuffer h) -> Int -> ST h (STBuffer h) -concat' = Internal.concat' +concat' = unsafeCoerce Buffer.concat' copy :: forall h. Int -> Int -> STBuffer h -> Int -> STBuffer h -> ST h Int -copy = Internal.copy +copy = unsafeCoerce Buffer.copy fill :: forall h. Int -> Int -> Int -> STBuffer h -> ST h Unit -fill = Internal.fill +fill = unsafeCoerce Buffer.fill From d2c33a036514cc7dbb776204dda103c4014753d4 Mon Sep 17 00:00:00 2001 From: Jordan Martinez Date: Wed, 5 Jul 2023 07:50:36 -0500 Subject: [PATCH 3/3] Add changelog entry --- CHANGELOG.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 0c6026e..6fb6fa6 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -49,6 +49,8 @@ Bugfixes: Other improvements: - Format code with `purs-tidy`; enforce in CI (#52 by @JordanMartinez) +- Update FFI to use uncurried functions (#54 by @JordanMartinez) +- Removed `Internal.purs` file (#54 by @JordanMartinez) ## [v8.0.0](https://github.com/purescript-node/purescript-node-buffer/releases/tag/v8.0.0) - 2022-04-27