Iterable, the top rated AI-powered customer communication platform that helps brands activate customers at scale, today unveiled its 2023 Fall Product Release, which includes new AI-Driven Experiments,

Iterable Introduces AI-Powered Experiments and Identity Toolkit to Help Brands Accelerate Marketing Innovation

Iterable, a customer communication platform provider, today unveiled its 2023 Fall product release with new AI-Driven Experiments, a new Identity Toolkit, and expanded data partner integrations. "In today's fast-paced and evolving digital landscape,

Iterable Introduces AI-Powered Experiments and Identity Toolkit

It's possible to read and write JSON files in Node.js. All you need to do is utilize the fs Module as detailed in our easy-to-follow guide. Reading and Writing JSON files in Node.js The JavaScript Object Notation format, popularly known as JSON, is a ...

How to Read and Write JSON Files in Node.js

The Node.js file system ( fs) module is built into Node.js. It lets you interact with the file system on your device. You can use it to read the contents of a file, create a new file, and delete a file, among other things. Continue reading readFile writeFile fs synchronous or asynchronous readFileSync writeFileSync users.json fs

Accelerate your tech game Paid Content How the New Space Race Will Drive Innovation How the metaverse will change the future of work and society Managing the Multicloud The Future of the Internet ...

New cheaper Apple Pencil unveiled: Here's how it compares to its predecessors

Iterable Recognized for its Ability to Execute and Completeness of Vision SAN FRANCISCO–(BUSINESS WIRE)–Iterable, an AI-powered customer communication platform that helps brands like DoorDash, Volvo and Priceline deliver individualized, harmonized and ...

Iterable Recognized as a Challenger in 2023 Gartner® Magic Quadrant™ for Multichannel Marketing Hubs

Iterable Recognized for its Ability to Execute and Completeness of Vision SAN FRANCISCO, October 04, 2023--(BUSINESS WIRE)--Iterable, an AI-powered customer communication platform that helps ...

Iterable Recognized for its Ability to Execute and Completeness of Vision Iterable, an AI-powered customer communication platform that helps brands like DoorDash, Volvo and Priceline deliver ...

About Iterable Iterable is the top-rated AI-powered cross-channel customer communication platform that helps organizations like Redfin, DoorDash, Calm, and Box to activate customers with joyful ...

Zach began writing for CNET in November, 2021 after writing for a broadcast news station in his hometown, Cincinnati, for five years. You can usually find him reading and drinking coffee or ...

iOS 17 Cheat Sheet: What You Should Know About the iPhone Update

Iterable

iterable

Python is a programming language having a range of features from simple to complex. It is a simple but expressive and powerful language. If you have learned the basics of Python, such as basic data structures and functionalities, then it's time to learn the complex features now. The new and can be discovered with the help of extensive research and experience. Python has got attractive solutions as advanced features for many complicated problems that occur during development. advanced features of the Python language More than one of these features can be used to solve a single Python problem. For example, if we want to , we can use List Comprehension as well as Lambda Function. iterate over a list in Python In this article, you will learn 12 useful advanced features of Python. You can take help from these advanced techniques in your code. Each method is explained along with code snippets and output for better understanding. Lambda Function A lambda function is defined without a name and thus called an anonymous function as well. It is a small function, and people usually refer to it as lambda only. It is one powerful tool for a data scientist. Typically, Python functions are defined using keyword along with the function name. As lambda has no name, it is defined with the keyword . def lambda Lambda function is basically used for the simple expression or operation where we need only a short one-time use function. This function takes arguments but can have only one expression. Let's understand this feature with the help of the below code. Here is the output: As you can see, it was pretty easy to use the lambda function without defining a complete full function. It makes Python code simple and clean. Generators It takes a lot of time to build iterables to iterate the Python objects. It is lengthy and quite unreasonable. Python Generator provides a simple way to declare a function that works as an iterator just like it can be used in for-loop. The generator is a function that returns an object (iterator), upon which one value at a time can be iterated. Typical iterables like lists and dictionaries have their items loaded in the memory. Whereas generators produce elements slowly and it does not need to load all of those items in memory. Thus, Generator functions are memory-efficient iterables. Below code is the illustration of this technique. And the output: Map Function The Map is one of the commonly used functions in Python. It is a built-in Python function that makes work easier. Map() Function is applied on a function to a sequence of elements just like in a list or a dictionary. When a function and an iterables are passed in a map, the function is performed on each of those entities of that iterable by Map. The map function can be used with any of the Python functions if it is compatible with the element sequence being operated. Let's see the basic syntax and application with the following code. If we would use a typical approach, the code will be lengthy and complex. Map( ) function simplifies the code. We get the output. Decorators Decorator is an interesting feature of Python, which is used to add functionality to the existing code. The decorator takes in a function and returns it after adding some functionality. It modifies the function without changing the core functionalities of the function. This process is also called metaprogramming, as one part of the program tries to modify another part of the program while compiling. In simple words, Python decorators add some tweaks in regards to the function's look or some other aspects and do not change the internal algorithm. Here is an example: And here is the output: Comprehensions Comprehension is one of the most mentioned techniques in Python language. Comprehension makes it easy to create a list, dictionary, or set that is named as a list comprehension, Dictionary comprehension, and a Set comprehension, respectively. With the help of comprehension, we do not need to use for-loops. This technique is faster and more efficient than traditional loops. Syntax of all the comprehensions looks quite similar. The code is more readable when Comprehension is used. The following code snippet explains this feature. Output is presented as follows. Filtering The Filter is a built-in function of Python. Like the Map function, Filter applies a function to a sequence of elements like list, tuple, dictionary. The primary difference between Map () and Filter () is that Filter () returns only those elements which are produced as True by applied function. It is a handy feature of Python to handle two steps: checking an expression and creating a return list. Here is one example code: Output we get is: Python Iterator Python Iterators are the objects which are iterated upon. We can see many iterators in Python. They have implementation inside for loop, comprehensions or generators, etc. Iterators in Python return one element at a time. Iterables are the objects that can get an iterator from them. For example, String, List, Tuple, etc. are iterables. The following example shows python iterator code. Here is the output: Hashability Hashing is a process of using a hash function for a particular Python object that can be hashed. In Python dictionaries, the keys should be hashable. Hashability makes Python objects be converted to numeric hashed values. Hashing is a time-consuming process, but it provides you with instant look-up-time for fetching some particular element in the dictionary. It is an efficient mechanism for item insertion, item retrieval, and item checking. These are the main advantages of using hash tables as storage for dictionaries. Let's have a look at the example code. Output: Python RegEx RegEx stands for Regular Expression. A sequence of characters that is used to define a search pattern is called Regular Expression. RegEx defined patterns can be used to match against a string. The regular expressions are specified using meta characters i.e. , that are interpreted differently by RegEx Engine. [], ., ^, $, *, +, ?, {}, (), \, | RegEx is used to find the information that is based on complex patterns in text. In this way, RegEx is used to replace pattern in a string. There is one code defined by RegEx. The pattern is any string composed of five letters starting with and ending with . a s ^a…s$ The following example will help to understand RegEx. And Output is: IterTools IterTools is a Python module. This module is a collection of tools that helps to handle iterators. Iterator is one data type used for loops for lists, dictionaries, and tuples. Iterator Operations typically require multi-line functions and complex list comprehension. The functions in Itertools allow performing such iterator operations with a more effortless and simple approach. Here is an example code: Output: Python Closure The technique that attaches some data to the code is called Closure in Python. When a nested function in Python references a value in its enclosing scope, it will require a Python Closure. Closure provides an object-oriented solution approach to the problem. It hides some form of the data and prevents the use of global values. Python Decorators use closures as well. The below code is an illustration of the feature. And the output is: Python Property Python has a built-in decorator named @property, which uses getters and setters efficiently in an Object-Oriented Environment. Python property creates and returns a property object. A property object has three methods i.e. getter(), setter() and delete(). Let's understand this technique with the help of the following example. Here is the output: CONCLUSION: This article has explained all advanced practical concepts of Python. The techniques mentioned above are used to improvise one's coding skills. I hope you have a good understanding of all the advanced techniques, and it could help you in your Python development career.

A Guide to Python Advanced Features

What exactly is TypeError: ‘int’ object is not iterable? The most common scenario where developers get this error is when you try to iterate a number using for loop where you tend to forget to use the method, which creates a sequence of a number to iterate. range() Consider the following code snippet to accept grades for each student in a class. students=int(input('Please enter the number of students in the class: '))

for number in students:
        math_grade=(input("Enter student's Maths grade: "))
        science_grade=(input("Enter student's Science grade: "))
        social_grade=(input("Enter student's Scoial grade: "))

# Output

Please enter the number of students in the class: 5
Traceback (most recent call last):
  File "c:\Projects\Tryouts\listindexerror.py", line 3, in <module>
    for number in students:
TypeError: 'int' object is not iterable The above code is pretty straightforward, which reads input on the total number of students in a class, and for each student, it accepts the subject grades. The easier way everyone thinks here is to go with for loop and iterate the number of students to accept the grade. If you run the code, Python will throw a . TypeError: ‘int’ object is not iterable Why does Python throw TypeError: ‘int’ object is not iterable? In Python, unlike lists, integers are not directly iterable as they hold a single integer value and do not contain the  **‘ ‘ ** method; that’s why you get a . __iter__ TypeError You can run the below command to check whether an object is iterable or not. print(dir(int))
print(dir(list))
print(dir(dict)) If you look at the output screenshots, int does not have the ** ‘ ’ ** method, whereas the list and dict have the  ** ** method. iter ' iter ' How to fix TypeError: ‘int’ object is not iterable? There are two ways you can resolve the issue, and the first approach is instead of using int, try using a list if it makes sense, and it can be iterated using for and while loop easily. The second approach is: if you still want to iterate int object, then try using the method in the for loop, which will eventually generate a list of sequential numbers. range() students=int(input('Please enter the number of students in the class: '))

for number in range(students):
        math_grade=(input("Enter student's Maths grade: "))
        science_grade=(input("Enter student's Science grade: "))
        social_grade=(input("Enter student's Scoial grade: ")) The post appeared first on . Python TypeError: ‘int’ object is not iterable ItsMyCode

How to fix the Python TypeError: ‘int’ Object is not Iterable

Cómo arreglar el Python TypeError: el objeto 'int' no es iterable

One of the more impressive features of Python language is the use of “for-each” looping construct that has awed me ever since I started out with Python. For the uninitiated, here is a simple loop which prints the first 10 natural numbers: for for num in range(1, 11):print(num) We can also loop over the primitive types such as and in similar ways: list, tuples, dictionaries strings numbers = [1, 2, 3, 4, 5]record = ('Kshitij', 21, 'Loves Python')details = {'name': 'Kshitij','age': 21} for num in numbers:print(num) # 1 2 3 4 5 for data in record:print(data) # Kshitij 21 Loves Python for key, value in details.items():print(key, value) # age 21 name Kshitij As one implements few data structures in Python using , he feels the desire to loop over the data stored in it’s instances. This is where the Iterator Protocol comes into picture. class Sample Implementation Let us suppose we are tasked with implementing a . A sample implementation might look something like this: standard 52-card deck This works fine with regards to creating new instances of and representing it. However, a major pain point in this implementation is the lack of ability to iterate over the object. Deck Deck >>> from cards import Deck>>> new_deck = Deck() # New deck instantiated>>> print(new_deck)... # Works great>>> for card in new_deck:...     print(card) TypeError: 'Deck' object is not iterable One can be smart enough to explore the instance and conclude that the attributes holds the data required for iterations and it, in fact is a . With this knowledge, he can hack the above loop as follows: new_deck cards list >>> for card in new_deck.cards:...     print(card)Card(...).... This code works great. However, the end user must attain the internal information about the implementation to perform the iteration. This makes our code lose the advantages of data abstraction and leads much to be desired of the implementation. There must be a better way! Urged by the enthusiasm from Raymond Hettinger, I searched for ways to improve my implementation to couple with the Python’s loop. for And soon I found the answer — The Iterator Protocol. The Iterator Protocol In order to learn what the Protocol is and how to implement it in Python, we need to understand some basic terms. Iterable It is any object that . you can loop over with a for loop are not always indexable, they don’t always have lengths, and they’re not always finite. Iterables An iterable can be passed to built-in function to get an iterator for them. iter() Iterator Iterators have exactly one job: return the “next” item in our iterable. can be passed to the built-in function to get the next item from them and if there is no next item (because we reached the end), a exception will be raised. Iterators next StopIteration Iterators return themselves when passed to the built-in. iter() The Protocol Step 01: How the built-in works? iter() Whenever the interpreter needs to iterate over an object , it automatically calls . The built-in function: x iter(x) iter Checks whether the object implements, method and calls that to obtain an __iter__ iterator. If method is not implemented, but method is implemented, Python creates an that attempts to fetch items in order, starting from index . __iter__ __getitem__ iterator 0 If that fails, Python raises exception saying . TypeError <classname> object is not iterable Step 02: How to implement the Protocol? I will present two approaches to implementing the Iterator Protocol: Approach 1: Traditional Way Create a new class representing the (say ) iterator DeckIterator . Implement the following two methods in DeckIterator: : returns the next item in the iterable. __next__ : returns itself i.e . __iter__ self 3. Define an method in the class over whose instances you want to iterate i.e. class The method should return an instance of . __iter__ Deck. DeckIterator Approach 2: The Pragmatic Way Implement the method in the class as a . __iter__ Deck generator function Features This is the list of all the features that our object magically seem to support as soon as we implement the protocol. Iteration via for loop Unpacking similar to tuples Can be used in list comprehensions Can be used with built-in functions (such as , ) which consume an iterable. min max >>> new_deck = Deck() >>> # 1. Looping through a for loop>>> for card in new_deck:...     print(card) # Works great! >>> # 2. Unpacking similarly to tuples>>> first_card, *rest, last_card = new_deck >>> # 3. List Comprehensions>>> spades = [card for card in new_deck if card.suit == 'Spades'] >>> # 4. Built-in functions>>> max_card, min_card = max(new_deck), min(new_deck) Lessons Learnt: Iterators in Python aren’t a matter of type but of the protocol i.e. any class that implements this protocol can be iterated over. Python iteration. groks I hope that the knowledge of the Iterator Protocol will help you out when writing Python. In order to raise awareness about this seemingly under appreciated feature of Python, I have proposed a on this topic. talk at PyCon India 2017

How Iterables actually work in Python

Event Time Processing with Flink and Beam - Power of Real time Analytics

Creating a Service for Sensitive Data with Spring and Redis

Which Map Transformation Should I Use? Map transformation functions find common usage in Android development. They are part of the Kotlin Standard Library, a library built by JetBrains to provide standard functionality across Kotlin codebases. Inside the Standard Library is a package called kotlin.collections, containing the building blocks for different collections. These include Lists, Maps, and Sets. The collections package also contains the map transformation functions. These functions take the contents of a collection and transform them into another collection containing the transformed state. Let’s take a look at some examples. The Map Transformation The first transformation is the map() function. val numbersList = listOf(1, 2, 3)
  numbersList.map { it + 1 }.also(::println) // listOf(2, 3, 4)

  val numbersMap = mapOf("one" to 1, 
                         "two" to 2, 
                         "three" to 3)
  numbersMap.map { it.value + 1 }.also(::println) // listOf(2, 3, 4)

  val numbersSet = setOf(1, 2, 3)
  numbersSet.map { it + 1 }.also(::println) // listOf(2, 3, 4) This function iterates over a collection and applies the transformation to each value within a lambda, before returning a new collection containing the transformed values. map() is available across different types of collections. The reason for this is because map() is an extension function on the Iterable interface. Most collections implement Iterable, meaning they can make use of the map function. Map collection types are different. They don’t implement Iterable, instead, they possess a separate extension method to provide a map function that iterates over each entry and returns a List of results. Map Transformations and Null Values Map transformations come in different forms. Another useful transformation is the mapNotNull() function. val numbersList = listOf(1, 2, 3)
  numbersList.mapNotNull { if (it + 1 == 3) null else it + 1  }.also(::println) // listOf(2, 4)

  val numbersMap = mapOf("one" to 1, 
                         "two" to 2, 
                         "three" to 3)

  numbersMap.mapNotNull { if (it.value + 1 == 3) null else it.value + 1 }.also(::println) // listOf(2, 4)

  val numbersSet = setOf(1, 2, 3)
  numbersSet.mapNotNull { if (it + 1 == 3) null else it + 1 }.also(::println) // listOf(2, 4) This function acts both as a transformation function and a filter for null values. If the transformation inside the lambda results in null, then the value is not added to the new list. mapNotNull() is available to collections implementing the Iterable interface. Map types have their own extension function to provide similar functionality. Returning a list of results. Acquiring an Index with Map Transformations If you need to know the location of the value within the collection being transformed, you can use mapIndexed(). val numbersList = listOf(1, 2, 3)
  numbersList.mapIndexed { index, number -> number + index + 1 }.also(::println) // listOf(2, 4, 6)

  val numbersMap = mapOf("one" to 1, 
                         "two" to 2, 
                         "three" to 3)
  
  numbersMap.asIterable().mapIndexed { index, entry -> entry.value + index + 1 }.also(::println) // listOf(2, 4, 6)

  val numbersSet = setOf(1, 2, 3)
  numbersSet.mapIndexed { index, number -> number + index + 1 }.also(::println) // listOf(2, 4, 6) Here, the location of the value (the index) within the collection is passed alongside the value being transformed. mapIndexed() is available to collections implementing the Iterable interface. Map types don’t have a mapIndexed() extension function. What you can do though is use the asIterable() extension to wrap the Map inside an Iterable instance. Then you can use mapIndexed() without issue. If you need to check for null values and also require an index, you can also use mapIndexedNotNull(). val numbersList = listOf(1, 2, 3)
  numbersList.mapIndexedNotNull { index, number -> if (number + 1 == 3) null else number + index + 1 }.also(::println) // listOf(2, 6)
  
  val numbersMap = mapOf("one" to 1, 
                         "two" to 2, 
                         "three" to 3)
  
  numbersMap.asIterable().mapIndexedNotNull { index, entry -> if (entry.value + 1 == 3) null else entry.value + index + 1 }.also(::println) // listOf(2, 6)

  val numbersSet = setOf(1, 2, 3)
  numbersSet.mapIndexedNotNull { index, number -> if (number + 1 == 3) null else number + index + 1 }.also(::println) //listOf(2, 6) mapIndexedNotNull() works similarly to mapNotNull(). It filters away null values within the transformation lambda whilst also passing in the index for the value from the collection. Like other map transformations, it exists on all types implementing Iterable. Map types can use the asIterable() function to gain access to mapIndexedNotNull(). Other Transformations for Map Types Map types work differently than other collections due to not implementing the Collection or Iterable interfaces. Because of this, they have a few of their own transformation functions not available to other types. The first is called mapKeys(). val numbersMap = mapOf("one" to 1, 
                         "two" to 2, 
                         "three" to 3)
  
  numbersMap.mapKeys { entry -> entry.key.capitalize() }.also(::println) // mapOf("One" to 1, "Two" to 2, "Three" to 3) mapKeys() transforms each key within the map by passing through each Entry of the map. Once all the transformations are complete, they are applied to the Map. The second function is called mapValues(). val numbersMap = mapOf("one" to 1, 
                         "two" to 2, 
                         "three" to 3)
  
  numbersMap.mapValues { entry -> entry.value + 1 }.also(::println) // mapOf("one" to 2, "two" to 3, "three" to 4) mapValues() works in a similar way. It passes through each Entry of the map and transforms each value. Once all the transformations are complete they are applied to the map. Passing Map Transformations to a Destination If you want to pass applied transformations to a different collection other than the source, there are a few functions to help. val numbersList = listOf(1, 2, 3)
  val numbersDestinationSet = mutableSetOf<Int>()
  numbersList.mapTo(numbersDestinationSet) { it + 1 }
  println(numbersDestinationSet) // setOf(2, 3, 4)

  val numbersSet = setOf(1, 2, 3)
  val numbersDestinationList = mutableListOf<Int>()
  numbersSet.mapTo(numbersDestinationList) { it + 1 }
  println(numbersDestinationList) // listOf(2, 3, 4) The mapTo functions work similarly to map(). The difference is they write the transformations to the passed-in collection. The collection being written doesn’t have to be the same type as the source collection. Useful if you have a usecase where a different collection would be more optimal. Map types can’t use mapTo(). This is because mapTo() expects to write to a MutableCollection, which Map types don’t inherit from. There is a MutableMap type, however, because it doesn’t inherit from MutableCollection there is no mapTo() extension available. More Resources If you’d like to learn more about Kotlin’s transformation methods. I highly recommend this page on collection transformations from the Kotlin language documentation. As well as covering map transformations it also covers other methods like zipping, association, and flattening. These topics are beyond the scope of this post, however, they are nevertheless useful to understand. Which Map Transformation Should I Use? Map transformation functions find common usage in Android development. They are part of the Kotlin Standard Library , a library built by JetBrains to provide standard functionality across Kotlin codebases. Kotlin Standard Library Inside the Standard Library is a package called kotlin.collections , containing the building blocks for different collections. These include Lists , Maps , and Sets . kotlin.collections Lists Maps Sets The collections package also contains the map transformation functions. These functions take the contents of a collection and transform them into another collection containing the transformed state. Let’s take a look at some examples. The Map Transformation The first transformation is the map() function. map() val numbersList = listOf(1, 2, 3)
  numbersList.map { it + 1 }.also(::println) // listOf(2, 3, 4)

  val numbersMap = mapOf("one" to 1, 
                         "two" to 2, 
                         "three" to 3)
  numbersMap.map { it.value + 1 }.also(::println) // listOf(2, 3, 4)

  val numbersSet = setOf(1, 2, 3)
  numbersSet.map { it + 1 }.also(::println) // listOf(2, 3, 4) val numbersList = listOf(1, 2, 3)
  numbersList.map { it + 1 }.also(::println) // listOf(2, 3, 4)

  val numbersMap = mapOf("one" to 1, 
                         "two" to 2, 
                         "three" to 3)
  numbersMap.map { it.value + 1 }.also(::println) // listOf(2, 3, 4)

  val numbersSet = setOf(1, 2, 3)
  numbersSet.map { it + 1 }.also(::println) // listOf(2, 3, 4) This function iterates over a collection and applies the transformation to each value within a lambda, before returning a new collection containing the transformed values. map() is available across different types of collections. The reason for this is because map() is an extension function on the Iterable interface. Most collections implement Iterable , meaning they can make use of the map function. map() map() Iterable Iterable Map collection types are different. They don’t implement Iterable , instead, they possess a separate extension method to provide a map function that iterates over each entry and returns a List of results. Iterable extension method Map Transformations and Null Values Map transformations come in different forms. Another useful transformation is the mapNotNull() function. mapNotNull() val numbersList = listOf(1, 2, 3)
  numbersList.mapNotNull { if (it + 1 == 3) null else it + 1  }.also(::println) // listOf(2, 4)

  val numbersMap = mapOf("one" to 1, 
                         "two" to 2, 
                         "three" to 3)

  numbersMap.mapNotNull { if (it.value + 1 == 3) null else it.value + 1 }.also(::println) // listOf(2, 4)

  val numbersSet = setOf(1, 2, 3)
  numbersSet.mapNotNull { if (it + 1 == 3) null else it + 1 }.also(::println) // listOf(2, 4) val numbersList = listOf(1, 2, 3)
  numbersList.mapNotNull { if (it + 1 == 3) null else it + 1  }.also(::println) // listOf(2, 4)

  val numbersMap = mapOf("one" to 1, 
                         "two" to 2, 
                         "three" to 3)

  numbersMap.mapNotNull { if (it.value + 1 == 3) null else it.value + 1 }.also(::println) // listOf(2, 4)

  val numbersSet = setOf(1, 2, 3)
  numbersSet.mapNotNull { if (it + 1 == 3) null else it + 1 }.also(::println) // listOf(2, 4) This function acts both as a transformation function and a filter for null values. If the transformation inside the lambda results in null , then the value is not added to the new list. null mapNotNull() is available to collections implementing the Iterable interface. mapNotNull() Iterable Map types have their own extension function to provide similar functionality. Returning a list of results. extension function Acquiring an Index with Map Transformations If you need to know the location of the value within the collection being transformed, you can use mapIndexed() . mapIndexed() val numbersList = listOf(1, 2, 3)
  numbersList.mapIndexed { index, number -> number + index + 1 }.also(::println) // listOf(2, 4, 6)

  val numbersMap = mapOf("one" to 1, 
                         "two" to 2, 
                         "three" to 3)
  
  numbersMap.asIterable().mapIndexed { index, entry -> entry.value + index + 1 }.also(::println) // listOf(2, 4, 6)

  val numbersSet = setOf(1, 2, 3)
  numbersSet.mapIndexed { index, number -> number + index + 1 }.also(::println) // listOf(2, 4, 6) val numbersList = listOf(1, 2, 3)
  numbersList.mapIndexed { index, number -> number + index + 1 }.also(::println) // listOf(2, 4, 6)

  val numbersMap = mapOf("one" to 1, 
                         "two" to 2, 
                         "three" to 3)
  
  numbersMap.asIterable().mapIndexed { index, entry -> entry.value + index + 1 }.also(::println) // listOf(2, 4, 6)

  val numbersSet = setOf(1, 2, 3)
  numbersSet.mapIndexed { index, number -> number + index + 1 }.also(::println) // listOf(2, 4, 6) Here, the location of the value (the index) within the collection is passed alongside the value being transformed. mapIndexed() is available to collections implementing the Iterable interface. mapIndexed() Iterable Map types don’t have a mapIndexed() extension function. What you can do though is use the asIterable() extension to wrap the Map inside an Iterable instance. Then you can use mapIndexed() without issue. mapIndexed() asIterable() mapIndexed() If you need to check for null values and also require an index, you can also use mapIndexedNotNull() . mapIndexedNotNull() val numbersList = listOf(1, 2, 3)
  numbersList.mapIndexedNotNull { index, number -> if (number + 1 == 3) null else number + index + 1 }.also(::println) // listOf(2, 6)
  
  val numbersMap = mapOf("one" to 1, 
                         "two" to 2, 
                         "three" to 3)
  
  numbersMap.asIterable().mapIndexedNotNull { index, entry -> if (entry.value + 1 == 3) null else entry.value + index + 1 }.also(::println) // listOf(2, 6)

  val numbersSet = setOf(1, 2, 3)
  numbersSet.mapIndexedNotNull { index, number -> if (number + 1 == 3) null else number + index + 1 }.also(::println) //listOf(2, 6) val numbersList = listOf(1, 2, 3)
  numbersList.mapIndexedNotNull { index, number -> if (number + 1 == 3) null else number + index + 1 }.also(::println) // listOf(2, 6)
  
  val numbersMap = mapOf("one" to 1, 
                         "two" to 2, 
                         "three" to 3)
  
  numbersMap.asIterable().mapIndexedNotNull { index, entry -> if (entry.value + 1 == 3) null else entry.value + index + 1 }.also(::println) // listOf(2, 6)

  val numbersSet = setOf(1, 2, 3)
  numbersSet.mapIndexedNotNull { index, number -> if (number + 1 == 3) null else number + index + 1 }.also(::println) //listOf(2, 6) mapIndexedNotNull() works similarly to mapNotNull() . It filters away null values within the transformation lambda whilst also passing in the index for the value from the collection. mapIndexedNotNull() mapNotNull() Like other map transformations, it exists on all types implementing Iterable. Map types can use the asIterable() function to gain access to mapIndexedNotNull() . asIterable() mapIndexedNotNull() Other Transformations for Map Types Map types work differently than other collections due to not implementing the Collection or Iterable interfaces. Because of this, they have a few of their own transformation functions not available to other types. Collection The first is called mapKeys() . mapKeys() val numbersMap = mapOf("one" to 1, 
                         "two" to 2, 
                         "three" to 3)
  
  numbersMap.mapKeys { entry -> entry.key.capitalize() }.also(::println) // mapOf("One" to 1, "Two" to 2, "Three" to 3) val numbersMap = mapOf("one" to 1, 
                         "two" to 2, 
                         "three" to 3)
  
  numbersMap.mapKeys { entry -> entry.key.capitalize() }.also(::println) // mapOf("One" to 1, "Two" to 2, "Three" to 3) mapKeys() transforms each key within the map by passing through each Entry of the map. Once all the transformations are complete, they are applied to the Map. mapKeys() The second function is called mapValues() . mapValues() val numbersMap = mapOf("one" to 1, 
                         "two" to 2, 
                         "three" to 3)
  
  numbersMap.mapValues { entry -> entry.value + 1 }.also(::println) // mapOf("one" to 2, "two" to 3, "three" to 4) val numbersMap = mapOf("one" to 1, 
                         "two" to 2, 
                         "three" to 3)
  
  numbersMap.mapValues { entry -> entry.value + 1 }.also(::println) // mapOf("one" to 2, "two" to 3, "three" to 4) mapValues() works in a similar way. It passes through each Entry of the map and transforms each value. Once all the transformations are complete they are applied to the map. mapValues() Entry Passing Map Transformations to a Destination If you want to pass applied transformations to a different collection other than the source, there are a few functions to help. val numbersList = listOf(1, 2, 3)
  val numbersDestinationSet = mutableSetOf<Int>()
  numbersList.mapTo(numbersDestinationSet) { it + 1 }
  println(numbersDestinationSet) // setOf(2, 3, 4)

  val numbersSet = setOf(1, 2, 3)
  val numbersDestinationList = mutableListOf<Int>()
  numbersSet.mapTo(numbersDestinationList) { it + 1 }
  println(numbersDestinationList) // listOf(2, 3, 4) val numbersList = listOf(1, 2, 3)
  val numbersDestinationSet = mutableSetOf<Int>()
  numbersList.mapTo(numbersDestinationSet) { it + 1 }
  println(numbersDestinationSet) // setOf(2, 3, 4)

  val numbersSet = setOf(1, 2, 3)
  val numbersDestinationList = mutableListOf<Int>()
  numbersSet.mapTo(numbersDestinationList) { it + 1 }
  println(numbersDestinationList) // listOf(2, 3, 4) The mapTo functions work similarly to map() . The difference is they write the transformations to the passed-in collection. The collection being written doesn’t have to be the same type as the source collection. Useful if you have a usecase where a different collection would be more optimal. mapTo map() Map types can’t use mapTo() . This is because mapTo() expects to write to a MutableCollection , which Map types don’t inherit from. There is a MutableMap type, however, because it doesn’t inherit from MutableCollection there is no mapTo() extension available. mapTo() mapTo() MutableCollection MutableMap MutableCollection mapTo() More Resources If you’d like to learn more about Kotlin’s transformation methods. I highly recommend this page on collection transformations from the Kotlin language documentation. As well as covering map transformations it also covers other methods like zipping, association, and flattening. These topics are beyond the scope of this post, however, they are nevertheless useful to understand. this page

Map Transformation: Which One Should I Use?

Helloooooooo! Hope you're doing great! This is SMY! 👋 Let's jump right in 🚀 Source Code: https://github.com/smyaseen/typescript-sdk-template Contents: ⚡ Some Background of SDK Development
⚡ Developing and running our first version 1️⃣ What - SDK (sometimes also known as library) serves as a plug-in in applications to derive additional features from the technology. 2️⃣ Why - SDK development with TypeScript offers reliability over a long time due to type safety and maintenance in the long run. 3️⃣ How - The fundamental steps required to build the SDK are the following: Initializing the project with the right workflow settings.
Choosing Bundler, and understanding its purpose.
Understanding ESM, CJS, IIFE UMD to run SDK on different environments.
Publishing as a library on NPM, semantic versioning, and License.
NPM for SPAs and CDN for Browsers. In Part 1, we are going to build our first basic SDK to get a basic understanding. Step 1: Initialize Project Run the following command to set the project in a new folder: npm init -y "-y" defaults to yes to all the follow-up prompts. You can change it later in the Package.json like the author, license, version, etc. Head over to package.json, and add type: module to work with the latest EcmaScript Module system (ESM). Your package.json should look like the following: {
  "name": "ts-lib",
  "version": "1.0.0",
  "description": "SDK development tutorial",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "type": "module",
  "keywords": [],
  "author": "",
  "license": "ISC"
} Step 2: Install Fundamental Dev Libraries TypeScript
@types/node - to work TypeScript with NodeJS.
tsup - The simplest and fastest way to bundle your TypeScript libraries. COPY npm i typescript @types/node tsup -D Step 3: Setup tsconfig for TypeScript Settings Create a tsconfig.json file at the root of the project. COPY touch tsconfig.json Head over to the file, and paste the following configuration: {
  "compilerOptions": {
    /* Base Options: */
    "esModuleInterop": true,
    "allowImportingTsExtensions": true,
    "emitDeclarationOnly": true,
    "skipLibCheck": true,
    "target": "es2022",
    "allowJs": true,
    "resolveJsonModule": true,
    "moduleDetection": "force",
    "isolatedModules": true,
    "verbatimModuleSyntax": true,

    /* Strictness */
    "strict": true,
    "noUncheckedIndexedAccess": true,
    "noImplicitOverride": true,

    /* If transpiling with TypeScript: */
    "module": "NodeNext",
    "sourceMap": true,
    "outDir": "dist",

    /* AND if you're building for a library: */
    "declaration": true,

    /* If your code runs in the DOM: */
    "lib": ["es2022", "dom", "dom.iterable"]
  },
  "exclude": ["node_modules", "dist"]
} You can hover over each property to learn more in-depth about it. The fundamental thing to understand here is: "module": "NodeNext",
    "sourceMap": true,
    "outDir": "dist", " NodeNext is the right option for authoring libraries because it prevents you from emitting ESM with module specifiers that only work in bundlers but will crash in Node.js. When writing conventional code, using common sense, and relying on high-quality dependencies, its output is usually highly compatible with bundlers and other runtimes." You can learn more about it here: https://blog.andrewbran.ch/is-nodenext-right-for-libraries-that-dont-target-node-js/


sourceMap - Enables the generation of source files. These files allow debuggers and other tools to display the original TypeScript source code when working with the emitted JavaScript files. You can disable it for production.


outDir - Specify an output folder for all emitted files. /* AND if you're building for a library: */
    "declaration": true,

    /* If your code runs in the DOM: */
    "lib": ["es2022", "dom", "dom.iterable"] declaration - Generate .d.ts files from TypeScript and JavaScript files in your project.


lib - Specify a set of bundled library declaration files that describe the target runtime environment. es2022 is for node applications like React, and dom & dom.iterable for running the library in the browser. Step 4: Write Our First Code Create a index.ts file, and write the following basic code: const add = (a: number, b: number): number => a + b;
const subtract = (a: number, b: number): number => a - b;

export { add, subtract }; Build our first code: COPY tsup ./index.ts You may now see we have a dist folder with an output file index.cjs Let's integrate and run our first SDK! Create a app.js file, and paste the following code: import { add, subtract } from "./dist/index.cjs";

console.log(add(1, 2));
console.log(subtract(2, 1)); Since we haven't published our SDK, we are directly linking with local build. Now, run our first app node app.js You should see the following output: 3
1 Congrats 🎉🥳 🚀🚀🚀 We just built and ran our first SDK! Wrapping Up: We Just completed the basic steps to build and run our first SDK. Head over to Part 2, where we will build a basic folder structure, and integrate an External API endpoint 🚀 ..... Now, you're equipped with knowledge to build your own SDK. Happy coding! 🚀 That's it, folks! Hope it was a good read for you. Thank you! ✨ 👉 Follow me GitHub LinkedIn Helloooooooo! Helloooooooo! Hope you're doing great! This is SMY! 👋 Let's jump right in 🚀 Source Code: https://github.com/smyaseen/typescript-sdk-template https://github.com/smyaseen/typescript-sdk-template https://github.com/smyaseen/typescript-sdk-template Contents: ⚡ Some Background of SDK Development ⚡ Developing and running our first version ⚡ Some Background of SDK Development Some Background of SDK Development ⚡ Developing and running our first version Developing and running our first version 1️⃣ What - SDK (sometimes also known as library) serves as a plug-in in applications to derive additional features from the technology. 2️⃣ Why - SDK development with TypeScript offers reliability over a long time due to type safety and maintenance in the long run. 3️⃣ How - The fundamental steps required to build the SDK are the following: Initializing the project with the right workflow settings. Choosing Bundler, and understanding its purpose. Understanding ESM, CJS, IIFE UMD to run SDK on different environments. Publishing as a library on NPM, semantic versioning, and License. NPM for SPAs and CDN for Browsers. Initializing the project with the right workflow settings. Choosing Bundler, and understanding its purpose. Understanding ESM, CJS, IIFE UMD to run SDK on different environments. Publishing as a library on NPM, semantic versioning, and License. NPM for SPAs and CDN for Browsers. In Part 1, we are going to build our first basic SDK to get a basic understanding. Step 1: Initialize Project Run the following command to set the project in a new folder: npm init -y npm init -y "-y" defaults to yes to all the follow-up prompts. You can change it later in the Package.json like the author, license, version, etc. "-y" Head over to package.json , and add type: module to work with the latest EcmaScript Module system (ESM). package.json type: module Your package.json should look like the following: package.json {
  "name": "ts-lib",
  "version": "1.0.0",
  "description": "SDK development tutorial",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "type": "module",
  "keywords": [],
  "author": "",
  "license": "ISC"
} {
  "name": "ts-lib",
  "version": "1.0.0",
  "description": "SDK development tutorial",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "type": "module",
  "keywords": [],
  "author": "",
  "license": "ISC"
} Step 2: Install Fundamental Dev Libraries TypeScript @types/node - to work TypeScript with NodeJS. tsup - The simplest and fastest way to bundle your TypeScript libraries. TypeScript @types/node - to work TypeScript with NodeJS. @types/node tsup - The simplest and fastest way to bundle your TypeScript libraries. tsup COPY npm i typescript @types/node tsup -D npm i typescript @types/node tsup -D Step 3: Setup tsconfig for TypeScript Settings tsconfig Create a tsconfig.json file at the root of the project. tsconfig.json COPY touch tsconfig.json touch tsconfig.json Head over to the file, and paste the following configuration: {
  "compilerOptions": {
    /* Base Options: */
    "esModuleInterop": true,
    "allowImportingTsExtensions": true,
    "emitDeclarationOnly": true,
    "skipLibCheck": true,
    "target": "es2022",
    "allowJs": true,
    "resolveJsonModule": true,
    "moduleDetection": "force",
    "isolatedModules": true,
    "verbatimModuleSyntax": true,

    /* Strictness */
    "strict": true,
    "noUncheckedIndexedAccess": true,
    "noImplicitOverride": true,

    /* If transpiling with TypeScript: */
    "module": "NodeNext",
    "sourceMap": true,
    "outDir": "dist",

    /* AND if you're building for a library: */
    "declaration": true,

    /* If your code runs in the DOM: */
    "lib": ["es2022", "dom", "dom.iterable"]
  },
  "exclude": ["node_modules", "dist"]
} {
  "compilerOptions": {
    /* Base Options: */
    "esModuleInterop": true,
    "allowImportingTsExtensions": true,
    "emitDeclarationOnly": true,
    "skipLibCheck": true,
    "target": "es2022",
    "allowJs": true,
    "resolveJsonModule": true,
    "moduleDetection": "force",
    "isolatedModules": true,
    "verbatimModuleSyntax": true,

    /* Strictness */
    "strict": true,
    "noUncheckedIndexedAccess": true,
    "noImplicitOverride": true,

    /* If transpiling with TypeScript: */
    "module": "NodeNext",
    "sourceMap": true,
    "outDir": "dist",

    /* AND if you're building for a library: */
    "declaration": true,

    /* If your code runs in the DOM: */
    "lib": ["es2022", "dom", "dom.iterable"]
  },
  "exclude": ["node_modules", "dist"]
} You can hover over each property to learn more in-depth about it. The fundamental thing to understand here is: "module": "NodeNext",
    "sourceMap": true,
    "outDir": "dist", "module": "NodeNext",
    "sourceMap": true,
    "outDir": "dist", " NodeNext is the right option for authoring libraries because it prevents you from emitting ESM with module specifiers that only work in bundlers but will crash in Node.js. When writing conventional code, using common sense, and relying on high-quality dependencies, its output is usually highly compatible with bundlers and other runtimes." You can learn more about it here: https://blog.andrewbran.ch/is-nodenext-right-for-libraries-that-dont-target-node-js/ sourceMap - Enables the generation of source files. These files allow debuggers and other tools to display the original TypeScript source code when working with the emitted JavaScript files. You can disable it for production. outDir - Specify an output folder for all emitted files. " NodeNext is the right option for authoring libraries because it prevents you from emitting ESM with module specifiers that only work in bundlers but will crash in Node.js. When writing conventional code, using common sense, and relying on high-quality dependencies, its output is usually highly compatible with bundlers and other runtimes." You can learn more about it here: https://blog.andrewbran.ch/is-nodenext-right-for-libraries-that-dont-target-node-js/ " NodeNext is the right option for authoring libraries because it prevents you from emitting ESM with module specifiers that only work in bundlers but will crash in Node.js. When writing conventional code, using common sense, and relying on high-quality dependencies, its output is usually highly compatible with bundlers and other runtimes." You can learn more about it here: https://blog.andrewbran.ch/is-nodenext-right-for-libraries-that-dont-target-node-js/ NodeNext only https://blog.andrewbran.ch/is-nodenext-right-for-libraries-that-dont-target-node-js/ https://blog.andrewbran.ch/is-nodenext-right-for-libraries-that-dont-target-node-js/ sourceMap - Enables the generation of source files. These files allow debuggers and other tools to display the original TypeScript source code when working with the emitted JavaScript files. You can disable it for production. sourceMap - Enables the generation of source files. These files allow debuggers and other tools to display the original TypeScript source code when working with the emitted JavaScript files. You can disable it for production. sourceMap outDir - Specify an output folder for all emitted files. outDir - Specify an output folder for all emitted files. outDir /* AND if you're building for a library: */
    "declaration": true,

    /* If your code runs in the DOM: */
    "lib": ["es2022", "dom", "dom.iterable"] /* AND if you're building for a library: */
    "declaration": true,

    /* If your code runs in the DOM: */
    "lib": ["es2022", "dom", "dom.iterable"] declaration - Generate .d.ts files from TypeScript and JavaScript files in your project. lib - Specify a set of bundled library declaration files that describe the target runtime environment. es2022 is for node applications like React, and dom & dom.iterable for running the library in the browser. declaration - Generate .d.ts files from TypeScript and JavaScript files in your project. declaration - Generate .d.ts files from TypeScript and JavaScript files in your project. declaration lib - Specify a set of bundled library declaration files that describe the target runtime environment. es2022 is for node applications like React, and dom & dom.iterable for running the library in the browser. lib - Specify a set of bundled library declaration files that describe the target runtime environment. es2022 is for node applications like React, and dom & dom.iterable for running the library in the browser. lib es2022 dom dom.iterable Step 4: Write Our First Code Create a index.ts file, and write the following basic code: index.ts const add = (a: number, b: number): number => a + b;
const subtract = (a: number, b: number): number => a - b;

export { add, subtract }; const add = (a: number, b: number): number => a + b;
const subtract = (a: number, b: number): number => a - b;

export { add, subtract }; Build our first code: COPY tsup ./index.ts tsup ./index.ts You may now see we have a dist folder with an output file index.cjs dist index.cjs Let's integrate and run our first SDK! Create a app.js file, and paste the following code: app.js import { add, subtract } from "./dist/index.cjs";

console.log(add(1, 2));
console.log(subtract(2, 1)); import { add, subtract } from "./dist/index.cjs";

console.log(add(1, 2));
console.log(subtract(2, 1)); Since we haven't published our SDK, we are directly linking with local build. Now, run our first app node app.js node app.js You should see the following output: 3
1 3
1 Congrats 🎉🥳 🚀🚀🚀 We just built and ran our first SDK! Wrapping Up: We Just completed the basic steps to build and run our first SDK. Head over to Part 2, where we will build a basic folder structure, and integrate an External API endpoint 🚀 ..... Now, you're equipped with knowledge to build your own SDK. Happy coding! 🚀 That's it, folks! Hope it was a good read for you. Thank you! ✨ 👉 Follow me GitHub GitHub GitHub LinkedIn LinkedIn LinkedIn

Stories, News & Mentions about ITERABLE

Iterable’s Stories on HackerNoon

Iterable's News & Mentions