Showing 32 of 32 total issues
Eta reduce Open
Open
diff expr symbol = (basic_binaryop basic_diff_ffi) expr symbol
- Read upRead up
- Exclude checks
Found
diff expr symbol = (basic_binaryop basic_diff_ffi) expr symbol
Perhaps
diff = (basic_binaryop basic_diff_ffi)
Eta reduce Open
Open
complex a b = (basic_binaryop complex_set_ffi) a b
- Read upRead up
- Exclude checks
Found
complex a b = (basic_binaryop complex_set_ffi) a b
Perhaps
complex = (basic_binaryop complex_set_ffi)
Eta reduce Open
Open
withBasicSym p f = withForeignPtr (fptr p ) f
- Read upRead up
- Exclude checks
Found
withBasicSym p f = withForeignPtr (fptr p) f
Perhaps
withBasicSym p = withForeignPtr (fptr p)
Avoid lambda Open
Open
withBasicSym3 p1 p2 p3 f = withBasicSym p1 (\p1 -> withBasicSym p2 (\p2 -> withBasicSym p3 (\p3 -> f p1 p2 p3)))
- Read upRead up
- Exclude checks
Found
\ p3 -> f p1 p2 p3
Perhaps
f p1 p2
Use camelCase Open
Open
basic_from_integer :: Integer -> BasicSym
- Read upRead up
- Exclude checks
Found
basic_from_integer :: Integer -> BasicSym
Perhaps
basicFromInteger :: Integer -> BasicSym
Use camelCase Open
Open
create_basic_ptr = do
basic_ptr <- newArray [BasicStruct { data_ptr = nullPtr }]
basic_new_heap_ffi basic_ptr
finalized_ptr <- newForeignPtr ptr_basic_free_heap_ffi basic_ptr
return $ BasicSym { fptr = finalized_ptr }
- Read upRead up
- Exclude checks
Found
create_basic_ptr = ...
Perhaps
createBasicPtr = ...
Use newtype instead of data Open
Open
data BasicStruct = BasicStruct {
data_ptr :: Ptr ()
}
- Read upRead up
- Exclude checks
Found
data BasicStruct = BasicStruct {data_ptr :: Ptr ()}
Perhaps
newtype BasicStruct = BasicStruct {data_ptr :: Ptr ()}
Applying this change:
- decreases laziness
Use camelCase Open
Open
minus_one :: BasicSym
- Read upRead up
- Exclude checks
Found
minus_one :: BasicSym
Perhaps
minusOne :: BasicSym
Use camelCase Open
Open
minus_one = basic_obj_constructor basic_const_minus_one_ffi
- Read upRead up
- Exclude checks
Found
minus_one = ...
Perhaps
minusOne = ...
Use camelCase Open
Open
basic_str basic_ptr = unsafePerformIO $ withBasicSym basic_ptr (basic_str_ffi >=> peekCString)
- Read upRead up
- Exclude checks
Found
basic_str basic_ptr = ...
Perhaps
basicStr basic_ptr = ...
Redundant bracket Open
Open
diff expr symbol = (basic_binaryop basic_diff_ffi) expr symbol
- Read upRead up
- Exclude checks
Found
(basic_binaryop basic_diff_ffi) expr
Perhaps
basic_binaryop basic_diff_ffi expr
Use newtype instead of data Open
Open
data BasicSym = BasicSym { fptr :: ForeignPtr BasicStruct }
- Read upRead up
- Exclude checks
Found
data BasicSym = BasicSym {fptr :: ForeignPtr BasicStruct}
Perhaps
newtype BasicSym = BasicSym {fptr :: ForeignPtr BasicStruct}
Applying this change:
- decreases laziness
Avoid lambda Open
Open
withBasicSym2 p1 p2 f = withBasicSym p1 (\p1 -> withBasicSym p2 (\p2 -> f p1 p2))
- Read upRead up
- Exclude checks
Found
\ p2 -> f p1 p2
Perhaps
f p1
Use camelCase Open
Open
basic_obj_constructor init_fn = unsafePerformIO $ do
basic_ptr <- create_basic_ptr
withBasicSym basic_ptr init_fn
return basic_ptr
- Read upRead up
- Exclude checks
Found
basic_obj_constructor init_fn = ...
Perhaps
basicObjConstructor init_fn = ...
Use camelCase Open
Open
ascii_art_str = ascii_art_str_ffi >>= peekCString
- Read upRead up
- Exclude checks
Found
ascii_art_str = ...
Perhaps
asciiArtStr = ...
Use camelCase Open
Open
basic_int_signed :: Int -> BasicSym
- Read upRead up
- Exclude checks
Found
basic_int_signed :: Int -> BasicSym
Perhaps
basicIntSigned :: Int -> BasicSym
Use camelCase Open
Open
basic_from_integer i = unsafePerformIO $ do
iptr <- create_basic_ptr
withBasicSym iptr (\iptr -> integer_set_si_ffi iptr (fromInteger i))
return iptr
- Read upRead up
- Exclude checks
Found
basic_from_integer i = ...
Perhaps
basicFromInteger i = ...
Use camelCase Open
Open
basic_binaryop :: (Ptr BasicStruct -> Ptr BasicStruct -> Ptr BasicStruct -> IO ()) -> BasicSym -> BasicSym -> BasicSym
- Read upRead up
- Exclude checks
Found
basic_binaryop ::
(Ptr BasicStruct -> Ptr BasicStruct -> Ptr BasicStruct -> IO ())
-> BasicSym -> BasicSym -> BasicSym
Perhaps
basicBinaryop ::
(Ptr BasicStruct -> Ptr BasicStruct -> Ptr BasicStruct -> IO ())
-> BasicSym -> BasicSym -> BasicSym
Use camelCase Open
Open
basic_obj_constructor :: (Ptr BasicStruct -> IO ()) -> BasicSym
- Read upRead up
- Exclude checks
Found
basic_obj_constructor :: (Ptr BasicStruct -> IO ()) -> BasicSym
Perhaps
basicObjConstructor :: (Ptr BasicStruct -> IO ()) -> BasicSym
Use camelCase Open
Open
ascii_art_str :: IO String
- Read upRead up
- Exclude checks
Found
ascii_art_str :: IO String
Perhaps
asciiArtStr :: IO String